No description
  • JavaScript 86.5%
  • CSS 8.7%
  • HTML 4.5%
  • Python 0.2%
Find a file
Dušan Bratuša a26b690d4c Choosing someone else turns the tree into theirs in one piece, in Lipa and in Družina
Lipa: each limb's control points used to slide to their new places on their own, so the
bough becoming the trunk floated free and the old trunk broke off as a separate piece, and
the whole crown blinked, its leaves being the trunk person's. Now every staying limb is
carried by a limb it grows from – the one in the new tree, or the one it grew from when that
comes to end where it starts – sliding along it, its reach swinging round and its bends
easing into the new ones. Someone moving between under and over the ground turns round on
the way: the old trunk sinks into a root carrying the chosen bough down to stand as the
trunk; a parent's root rises and lifts the old tree onto it. The crown's leaves belong to
the picture now (stage.crownLeaves), so they fill and thin instead of popping, and tufts
grow and shrink leaf by leaf. Bark, root colour, and leaf or knot fade from the old look to
the new. Those leaving draw back first; the new grow once the limbs are under way; the
name at the trunk's foot fades and the new one takes its place as the trunk stands.
The pure limb helpers (reversed, reachOf, nearestAlong) are in linden.js, with tests.

Družina and Celotno drevo: a move to someone else takes 900 ms, slower at both ends.
Relatives coming into view unfold out of the one they hang from, in a wave; those going
fold back into theirs as they fade. Lines going stay and fade with their cards; the
generations' bands and labels travel with their rows and give way to the new ones; on a
long way the camera draws back a little and comes in again. The focus card grows to its
size instead of snapping. Zoom, fit and recenter keep their short glide; with reduced
motion all of it is at once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 11:44:37 +01:00
.claude HeritageTree: self-hosted family tree app 2026-10-20 20:27:01 +02:00
docs A person's documents: records with their scans as pages, in an overlay 2026-11-07 10:14:00 +01:00
e2e A person's documents: records with their scans as pages, in an overlay 2026-11-07 10:14:00 +01:00
public Choosing someone else turns the tree into theirs in one piece, in Lipa and in Družina 2026-11-07 11:44:37 +01:00
server A person's documents: records with their scans as pages, in an overlay 2026-11-07 10:14:00 +01:00
test Choosing someone else turns the tree into theirs in one piece, in Lipa and in Družina 2026-11-07 11:44:37 +01:00
tools A photo's three versions: original, restored and colorized; originals added later by import 2026-10-29 07:34:49 +01:00
.dockerignore Keep Synology @eaDir folders out of the Docker image 2026-10-20 20:37:58 +02:00
.env.example Invite new users by e-mail 2026-10-21 08:33:34 +02:00
.gitignore Browser tests with Playwright (development only): sign-in, editing, read-only, English, share links, timeline 2026-10-21 13:20:15 +02:00
dev.db Father's and mother's line, highlighted in the whole tree 2026-10-21 09:52:15 +02:00
docker-compose.yml Deploy the NAS from git 2026-10-20 20:29:03 +02:00
docker-entrypoint.sh HeritageTree: self-hosted family tree app 2026-10-20 20:27:01 +02:00
Dockerfile HeritageTree: self-hosted family tree app 2026-10-20 20:27:01 +02:00
package-lock.json Faces found on the photos, and a review to name them 2026-10-22 13:07:16 +02:00
package.json Faces found on the photos, and a review to name them 2026-10-22 13:07:16 +02:00
playwright.config.js Faster with hundreds of photos, and on phones 2026-10-23 22:15:31 +02:00
README.md A person's documents: records with their scans as pages, in an overlay 2026-11-07 10:14:00 +01:00
update.sh update.sh: works through a link too, and is executable 2026-10-22 17:31:37 +02:00

HeritageTree

A self-hosted family tree editor. Node.js + SQLite, no build step, three runtime dependencies (Express, Nodemailer, and Leaflet for the map, served by the app itself). The interface is in Slovenian or English (user menu → English / Slovenščina, also on the sign-in screen); code, comments and the API are in English.

  • Three places: the top bar has Domov, Drevo and Galerija – large, the open one in the accent colour (on a phone, a bar at the bottom of the screen). Under the top bar, while the tree is open, Prikaz drevesa shows the family the other ways: Družina (the selected person's family, the chart), Celotno drevo, Pahljača, Tabela, Časovnica and Kraji; Drevo opens the last one used again. Opening the app always starts on Domov, wherever its address was left (a restored tab, the app on the home screen); a reload stays where it was, and so do the links in the app's e-mails, which carry ?open.
  • On a phone the screen is for the family's content: one slim bar at the top (the tree, 🔍, the user) that slides away while you read down Domov, the gallery or the table and comes back as soon as you scroll up; search opens over it, full width; Domov, Drevo and Galerija at the bottom, within reach of a thumb. Domov's news runs edge to edge, the composer waits as one line with the camera and a photo button beside it. The tree's six ways sit in one row of icons with a short word each. The gallery shows the photos two a row, with 🔍, + and ⋯ (the rest of its buttons) above them. A person opens as a profile to read – a tap on the card already selected, a finger held on any card, or picking them in search: when and where they were born and died, other names and notes, then the family to tap through, photos, memories and the life story; the form, and adding relatives, wait behind Uredi podatke (editors). The sheet closes when pulled down by its head. A photo opens full screen, on black: swipe sideways for the next or previous one, down to close (not while zoomed in). Its title, ♥ and comments wait in a strip at the foot – a tap pulls up the details, people, comments and tools, pulled down by its head they lower again; Kdo je kje shows the names on the faces (a computer shows them on hover). Who gave the hearts: a tap on a post's ♥ count, or a finger held on a heart. On a touch screen what is tapped is large enough for a fingertip and fields write at 16 px (iOS zooms in on smaller text); in a comment or post Enter starts a new line and Objavi sends it, and while you type the bar at the foot steps aside. Windows rise from the bottom as sheets with their buttons at the foot, fields one under another; menus and the @-suggestions stay on the screen and above the keyboard. A phone held sideways gives its little height to the content: Domov, Drevo and Galerija move into the one slim bar at the top (none at the foot), the tree's ways into a slim row, toolbars onto one line and the news into a column to read; a photo takes the whole screen with its details tucked into a strip at the foot (title, ♥, comments) – a tap on it, or the panel button beside ×, brings them up beside the photo, the button or a tap beside the photo tucks them down again – and sheets rise to the top – clear of the notch.
  • Buttons speak in one set of line glyphs (icons.js). The universal ones – send, edit, delete, download, play, close, more – show only their glyph, with its name as a tooltip; the others their glyph and word (Označi osebe, Neznan obraz, Uvozi ZIP, Nova oseba, Dodaj otroka …); saving and confirming stay words, and menus show a glyph before each item. A person's seldom-needed things – the memorial page, how they are related to someone, the father's and mother's lines, merging, deleting – are behind ⋯ in their head; where the head is narrow (beside the tree, on a phone) following and the story are in that ⋯ too, so the name keeps its room. Actions sit beside what they act on: in the photo viewer send, edit and delete on the heart's row, Označi osebe and Neznan obraz under the people on the photo, the rename pencil after the title; Novo srečanje beside its card's title on Domov, "all of them" links at a card's foot on the right; the gallery's count beside its title. On a phone the photo's tools show their word under each glyph, and a finger held on a glyph says its name.
  • Multiple trees: a switcher in the top bar creates, renames and deletes trees. Every tree is shared: everyone with access sees all of them, and editors (see below) change them.
  • A new tree from one person (veje): in a person's details, ⋯ → Novo drevo od te osebe … (whoever may create trees) makes a tree of their line – them, their descendants and the partners of them all – with its own Domov, news, gallery (empty at first), gatherings, share links and editors. Nobody moves: the people stay in the tree they come from, which looks as it did, and a change in either tree shows in both – a child added in the original is in the branch too, and anyone added while the branch is open (a daughter-in-law's parents) stays in it. The trees meet at that person: in the branch, a dashed card where their parents would be (↑ Janez in Marija Novak · v drevesu »…«, or with no parents written down ↑ Bratuša · izvorno drevo) leads to the original, and there their card has a tab with the branch's name that leads back; their details say the same. The switcher lists a branch under its tree. An editor given only the branch changes its people and nothing else. A branch exports on its own (Izvozi vsa drevesa leaves branches out – their people are in their tree's part); files are imported into the full tree; a tree goes to the bin only after its branches, and a branch goes without its people. (Branches as in TNG: a view from one person, kept up to date by itself.)
  • Domov (where the app opens): greets you by name (Dober dan, Dušan), shows Novice – the family's posts (below) – and beside them the gatherings ahead (Srečanja, below) and what the open tree has to say today – Na današnji dan (who was born, married or died on this date, life events and photos dated to it, with how long ago), the anniversaries and name days of the next two weeks, a photo from the gallery (Druga fotografija picks another), faces on the photos nobody has named yet (Kdo je na fotografiji?), the questions still open and, for editors, the latest changes. Names lead to the person in the tree, the photo opens the viewer, and the full lists are a click away. The HeritageTree logo leads back here; an empty tree opens in the tree view instead.
  • Tree view (Drevo → Družina): the selected person sits in the middle, with ancestors above, partners and siblings beside them and descendants below. Click anyone to move the tree to them; it animates into place, framing the whole family when it fits. The pencil on a card's corner (ⓘ for read-only users) opens their details. Arrow keys walk the tree (to the card beside, above or below) and Enter opens the details. Drag to pan, pinch or Ctrl/⌘+scroll to zoom. Each avatar carries a ring in the person's colour (fainter for the deceased); a small marker sits where a couple's line meets their children's – interlocked rings for a marriage, a dot otherwise, dashed when it ended – and the selected person's own lines are highlighted.
  • Celotno drevo (Drevo → Celotno drevo): everyone in the tree at once, one row per generation. Couples stand together, children sit under their parents, and in-laws' parents stand beside the family they married into. Families not connected to anyone appear next to it. The layout stays fixed while you click around (it only pans), and the setting is remembered. Big trees stay quick on phones: from 150 cards on, only those in and around the view are in the page (built when they first come into it), and lines far from it aren't drawn – a 2000-person tree pans in a few milliseconds a step. When the tree is bigger than the screen, a mini-map in the bottom-left corner shows all of it with a frame for what is on screen – click or drag on it to go there.
  • Pahljača (Drevo → Pahljača): the selected person's ancestors in a half circle, the father's side to the left and the mother's to the right, up to six generations, with their portrait in the middle. Click anyone to move the fan to them; the middle opens their details. The printed fan (Tisk in prenos) is drawn the same way.
  • Lipa (Drevo → Lipa): the family as a linden tree, painted and alive – its heart-shaped leaves move in a slow breeze, and now and then one lets go. It follows the year by the device's date: thin, dried leaves and a little snow in winter, pale new green in spring, blossom in June and July, gold and rust in autumn; each person's own leaf keeps its colour. The selected person is the trunk, their descendants the crown, their ancestors the roots (the father's side left, the mother's right, up to five generations), their brothers and sisters young shoots coming up from the same roots (from the trunk's foot with both parents in common, otherwise from the root of the parent they share), and each person's own leaf is green, or honey-gold for those no longer living. Children's limbs leave from their parent's own leaf, and names are in the device's own script. Selecting someone turns the tree into theirs, limb by limb: choose a parent and it grows, the old trunk becoming a bough; choose a child and it draws back to their branch, their bough becoming the trunk and the old trunk sinking to become a root. Someone with no descendants is a sapling with deep roots. As many names show as leave the tree a tree. Pointing at someone (or reaching them with the keyboard) lets the rest recede, leaving the way from the trunk to them, their brothers and sisters, their partner and those who come from them, with names. Pinching, Ctrl + wheel, + − 0 or the zoom buttons bring it closer and dragging moves it: the leaves spread apart while names keep their size, so more people get theirs, and selecting someone returns to the whole tree. The person at the trunk's foot opens their details; with reduced motion the tree changes without moving. It rustles and creaks softly as it grows, lower as it draws back, once a click or key has allowed the browser to play sound and unless Zvoki in the user menu is off (with reduced motion, silence); nothing else in the app makes a sound. The sounds are in public/sounds, with where they came from in SOURCES.txt.
  • How the tree looks: cards lie on warm paper (deep ink in dark mode). Someone with a photo gets it as a portrait down the card's left side – in sepia for the deceased, who also show the age they lived to (1925 – 1999 · 74 let). The selected person is raised with a soft glow, and cards further away in the family sit flatter. Generations are soft bands, named at the left edge relative to the selected person, with their birth years (Stari starši · r. 1925–1933, Starši, Ti, Otroci, Vnuki). The father's side and the mother's are told apart by a small tab on the cards and the colour of their lines (a cool slate and a warm clay, with a legend). Lines have soft corners, and the selected person's lines draw themselves in as the tree moves to them. A married couple's line carries the year (1980, 2005–2009 once it ended), and the date and place on hover. Resting the mouse on a card lights up the chain of lines from the selected person to them and shows a small card with their portrait, the relation (dedek), years, places and parents.
  • Tabela (Drevo → Tabela): everyone in the tree, each with their relationship to a reference person you pick (oče, babica, bratranec, tast, pastorek, …). The default order is genealogical: oldest generation first and, within a generation, closest relatives first. Click a column header to sort by it instead, or filter by name or year. The reference person is remembered per tree in each browser.
  • Fast entry: dashed Dodaj starša / partnerja / otroka slots next to the selected person. When you type a name, people already in the tree are suggested, so you can link them instead of creating duplicates.
  • Telling people of the same name apart: wherever you pick someone – tagging a face or Na fotografiji in the gallery, search, Je že v drevesu?, Kako je v sorodu z …, merging, GEDCOM review, DNA – each name comes with the birth surname (roj. Horvat – how a married woman appears in the registers), their years, where they were born and died and whose child they are (Ludvik Bratuša · 1902 – 1980 · Ptuj · † Maribor · sin od: Matija in Ana Kos), or whose spouse when no parents are known. Typing the birth surname finds her too. People of the same name are listed oldest first.
  • Names however they were spelled: old registers write a family the German, Hungarian or Latin way, and given names in Latin, German or pet forms. Search, the table filter, the data check's likely duplicates and the GEDCOM review match by sound – Bratusch or Brattuscha finds Bratuša, Kovatschitsch finds Kovačič – and know about 70 given names in their forms (Johann, Joannes and Ivan find Janez; Josephus finds Jožef; Franz finds Franc). The list is in public/js/name-variants.js.
  • Photos: click the round avatar in the details panel to add a photo, or drop an image onto the panel header. Once there is a photo, clicking the avatar shows it large, with Zamenjaj / Odstrani. The browser shrinks it to at most 800 px and re-encodes it as JPEG, so uploads stay around 100 kB and EXIF data such as GPS location is stripped. The photo then appears on the tile and wherever else the person is listed.
  • Časovnica (Drevo → Časovnica): everyone's life as a bar across the years, oldest first, against the times they lived in – Habsburška monarhija, Kraljevina SHS / Jugoslavija, SFRJ, Republika Slovenija, and the two world wars shaded. An end that isn't known fades out (a life of about 70 years is assumed); a dot marks the living. Hovering shows the year and how many of the family were alive then; clicking a row opens the person.
  • Galerija (third view): each photo can have up to three versions – the original (the untouched scan), a restored one (repaired, often by a program) and a colorised one; any of them may be missing, and any can be added later. Opening a photo shows its latest version (colorised, else restored, else the original); with more than one, words low on the photo (Original · Restavrirana · Pobarvana) fade slowly to another and back to compare them – the same spot, zoomed in too. A version of another shape than the latest (a scan with its border) is shown whole inside that one's frame, so people placed on the photo stay where they are. (Photos from before there were three versions had their restored version stored as the original; upgrading moves those to restored.) Images are shrunk in the browser to 2000 px on the longest side for viewing (a panorama keeps at least 1000 px of height, up to 6000 px wide), with a small thumbnail for the grid; pictures much wider or taller than a tile (a panorama, a long document) are shown whole in it, over a blurred copy, instead of being cut to their middle; photos like that uploaded before these sizes get Izboljšaj sličice (n) in the gallery's header (editors), which makes their images again from the kept originals, one by one with progress – or, without one, at least the thumbnail from the stored image – keeping the photo, its people and details as they are (not a change in the change log); the picked file itself is also kept untouched (up to 100 MB – e.g. a full-resolution scan, metadata included) and can be downloaded from the viewer (Prenesi original). Formats are whatever the browser can open (JPG, PNG, WebP; Safari also TIFF and HEIC). The grid is a mosaic in the pictures' own shapes – rows of one height, every photo as wide as its proportions ask, nothing cropped – with title and date on the photo when you point at it (always on a phone). In the viewer, a click shows the picture at its real size (a pixel of the kept original per screen pixel, around the spot clicked) and drag looks around; another click shows all of it again. The wheel, a pinch or + / − zoom in between; zoomed in, the full-resolution file is shown. Hovering a photo with versions in the grid shows its oldest one (a touch screen, with nothing to hover, doesn't load it). A photo opens with its thumbnail at once – never an empty frame or the photo before stretched to its shape – and turns sharp as soon as its picture has arrived; the photos either side are fetched and decoded ahead, so a swipe or an arrow shows the next one sharp straight away. Photos are ordered by the year in their date. A heart, a comment or an edit draws only that photo's tile anew, not the whole grid with its pictures.
  • Where a photo was taken: the photo editor has Kje je bila posneta (with the places already written in the tree to pick from). The viewer shows it after the date with Kako je tam danes ↗ – a map of the place as it is today, where Street View is a click away (a place written by its old name, Pettau, opens as Ptuj; nothing is sent until you click). Photos count among what happened at a place on the Kraji map, and a click opens them; the gallery search finds them by place too. Edits of the place are logged and can be undone.
  • Searching the gallery: under the gallery's toolbar, a search finds photos by title, description, date or the names of the people on them (capitals and accents don't matter, a birth surname counts – sola finds Šola v Ptuju), and a list narrows them to those with nobody tagged yet, those with faces nobody has named, or a decade (1950–1959). The count says 12 od 240 fotografij; the viewer pages through what is shown, and ▶ Predvajaj plays just that.
  • Many photos at once: Dodaj več … in the gallery (or dropping files anywhere on it) lists the picked photos, each with a title and date taken from its file name (1935_babica_na_vrtu.jpg → Babica na vrtu, 1935; IMG_20190514_….jpg → 14. 5. 2019) or the camera's own record (EXIF), to check before uploading. Scans keep only what their name says – scanners record the scan date, not the photo's. They are uploaded one by one as originals (with the untouched files), starting at once while the rest are still being looked at; any that fail stay in the list for another try, and Ustavi stops after the photo in hand. Photos already in the gallery (the same file name and size) are left out.
  • A ZIP of photos (Uvozi ZIP … in the gallery, or dropping a .zip on it, editors): the archive is read in the browser, one picture at a time, so even gigabytes of scans don't fill the memory (ZIP64 included; names from Windows' and Mac's own zips come out right, and __MACOSX, hidden and non-picture files are left out). The versions of one old photo become one gallery item – put together by a word in the name, poroka.jpg + poroka-restavrirana.jpg + poroka-barvna.jpg (also _barvna, barvna, (barvna), pobarvana, color, colorized …; obnovljena, restored, enhanced …; the original may say original, izvirnik, orig, čb), or by folders, originali/ + restavrirane/ + barvne/poroka.jpg, within the same folder otherwise. The title leaves the marker out (Poroka). Everything else is a photo of its own. Pictures that bring a photo already in the gallery a version it lacks are added to that photo instead – found by the name of a picture it keeps (or, keeping none, by its title), only where that is one picture for one photo – so an archive of just the original scans completes photos imported earlier as restored and colorised versions; their rows say Doda se fotografiji »Poroka«. The list says what was found (Družina.zip: 214 fotografij, od tega 37 z več različicami. 40 fotografij v galeriji dobi manjkajoče različice. 12 že v galeriji – preskočeno.); picked files are put together by the same rule. How to name and pack such an archive (for a person or an agent): docs/gallery-zip.md, with tools/make_gallery_zip.py, which shows how the app will pair the pictures and writes the ZIP.
  • People in photos: the photo editor has a Na fotografiji field – type a name to tag people of the tree. The viewer lists them (click a name to jump to that person), and each person's details panel shows the photos they are in. In the viewer, Označi osebe lets you click a face and pick who it is; names then appear on the photo when you hover it (they follow zoom and pan), a click on one opens the person, and in tagging mode a click removes it. Exports keep the places.
  • Portraits from the gallery (editors): Portret next to a name in the viewer, or Portret iz fotografij … under a person's photos, opens one of the photos they are in with a square over their face – where their tag is, else the middle. Drag it (or press elsewhere to move it there), change its size with the wheel, the slider or + / −, or move it with the arrow keys; the round preview shows the card as it will look, the strip above switches to their other photos, and a pair can be cut from either version. Uporabi kot portret cuts the square from the kept original (up to 800 px) and makes it their portrait.
  • Faces found on the photos (editors): while an editor has the app open on a computer, their browser looks the gallery's photos over for faces by itself, one at a time and each once – new ones as they arrive – with MediaPipe's face detector running right there (WebAssembly and model served by the app; no photo leaves for anywhere). Old group photos have small faces, so each photo is looked at whole and in some 400 smaller overlapping squares – seconds of work for each, so it runs in a background worker and the app stays quick meanwhile (a browser that can't run it there does it in the page). A phone or tablet looks only when asked (Poišči obraze, under ⋯ on a phone): it would take its battery, and fetch every photo whole, perhaps over mobile data. Preglej obraze (17) then opens the Mozaik: every face found at once, each with a box under it to type the name in – Enter places that person there and the next face's box is ready. What is no face at all goes with the × on it (or Delete in its empty box); Razveljavi in the note that follows brings it back. Click faces to pick several (Shift+click picks a whole run) and give them all one person from the bar below (once a photo: a second face picked on the same photo stays picked for another name), or send them to the relatives or dismiss them together. Eden po eden shows one face at a time instead, cut out of its photo with the whole photo beside it: the people tagged on that photo but not yet placed are offered first, anyone else by name; Ne vem – vprašaj sorodnike makes it a face for the relatives to guess, To ni obraz dismisses it for good, Pozneje leaves it. The search can be paused on a device (Iščem obraze … · ustavi) and resumed (Poišči obraze). The first search loads about 11 MB once.
  • Kdo je na fotografiji?: anyone with access, read-only users too, marks a face nobody knows – Neznan obraz in the viewer, then a click on the face (editors can also pick Ne vem, kdo je – vprašaj sorodnike while tagging). The face gets a question mark that is always shown; a click on it lists the guesses so far and takes one's own – a person of the tree, or words for someone who isn't in it (soseda Micka); a new guess takes the place of one's earlier one. Domov shows the faces still waiting, cut out of their photos, and leads straight to their guesses; the weekly e-mail says how many there are. An editor confirms a guess (Potrdi, or picks anyone for the question mark while tagging): the person is tagged on that spot, and the change log says who recognised them. Who marked a face or an editor removes the mark, guesses and all. Someone who can't edit the tree marks and guesses up to 30 times an hour. Guesses move with a merge and travel in JSON exports.
  • Export & import (tree menu): download one tree or all trees as a single JSON file, portraits and gallery included (files up to 250 MB import; for very large galleries, back up the data folder instead). The untouched original files are not part of exports – they stay in data/originals/. Importing a file always adds new trees and never overwrites existing ones; a name that's already taken gets " (2)". Every relationship goes through the same checks as manual editing, and if anything in the file is wrong, nothing is imported.
  • GEDCOM (tree menu): Izvozi to drevo kot GEDCOM writes a GEDCOM 5.5.1 file that other genealogy programs (MyHeritage, Ancestry, Gramps, FamilySearch …) can open. Admins can import .ged files through the same Uvozi iz datoteke … as JSON; the file becomes a new tree named after it. Carried over: names (incl. birth surname), sex, birth and death dates and places, notes (and occupations, into the notes), parents, couples with marriage and divorce, and sources with their citations. Photos are not part of it. Dates are converted both ways (okoli 1920 ↔ ABT 1920, 14. 4. 1950 ↔ 14 APR 1950). Each person keeps one pair of parents: when a file lists a birth and an adoptive family, the birth family is used.
  • CSV (spreadsheets): Izvozi to drevo kot tabelo CSV gives one row per person for Excel, LibreOffice or Google Sheets – id; ime; drugo ime; priimek; drugi priimek; rojstni priimek; spol; rojen; kraj rojstva; pokojni; umrl; kraj smrti; oče; mati; zakonec; partner; opombe, with oče, mati, zakonec and partner as ids of other rows (semicolons and a BOM, so Excel in Slovenia opens it as it is). A table back comes in through Uvozi iz datoteke … (a new tree, admins) or Uvozi GEDCOM ali CSV v to drevo … (the review below, editors) – so you can fill in dates in a spreadsheet and bring them back. Any table will do: columns are known by their headings in Slovenian or English (Ime, Priimek, Rojen, Kraj rojstva … or Given name, Surname, Born …; a lone Ime or Name holds the whole name), comma, semicolon or tab between fields, UTF-8 or Windows-1250; oče, mati, zakonec and partner may name someone by id or by name (Ana Kos finds Ana Bratuša, roj. Kos); columns it doesn't know go into the notes (Poklic: kmet). Several in one field are separated by ; or |. A name that is in the file twice, or not at all, or a quote left open, stops the import with the row to fix (rows counted as the spreadsheet counts them); a table can have up to 200 columns and 50,000 rows. Not carried in a table: kinds of parents, marriage details, events, sources and photos (JSON or GEDCOM keep them).
  • GEDCOM or CSV into an existing tree (tree menu → Uvozi GEDCOM ali CSV v to drevo …, editors): a file from another program, a relative or a spreadsheet is read first, and a review lists everyone in it – those the app recognises as already in the tree (same first name and surname, birth and death years that don't disagree, the closest one taken) with what would be filled in and the differences that will stay as the tree has them, and the new people. Unlink a wrong match, or link someone it didn't recognise, then Uvozi: matched people keep what they have and only get their empty fields filled (each an ordinary, undoable edit) and events they lack; new people are added; parents and couples are linked where that fits the tree – a link that doesn't (a third parent, a loop) is left out and listed; sources with a title the tree already has are reused. Bringing the same file in again adds nothing twice.
  • Tisk in prenos (tree menu): print (or Save as PDF in the print dialog) or download – Celotno drevo: everyone on one page with photos (SVG download too); Pahljača prednikov: the selected person's ancestors in a half circle, fathers' lines left and mothers' right, up to six generations (SVG too); Predniki: the selected person's ancestors generation by generation, numbered the genealogists' way (father of n is 2n, mother 2n + 1), each with birth, death, partners and occupation; Potomci: their descendants numbered 1, 1.1, 1.1.1 … in birth order, indented by generation (someone who appears twice, e.g. when cousins married, is described once and referred to after that); Družinska knjiga: a cover with the whole tree and then a page per person – photo, dates and places, family, life path with sources, notes, memories, documents and the photos they are in – with page numbers.
  • Koš (recycle bin): deleted people, gallery photos, documents, memories, questions, sources and trees stay restorable for 30 days (tree menu → Koš, or Razveljavi right after deleting), then they're removed for good. A restored person gets their relationships back. Each one is checked again against the tree as it is now, and any that no longer fit (e.g. the child got two other parents meanwhile) are left out, with a note saying so.
  • Zgodovina sprememb (change log): who added, changed, linked, deleted or restored what, and when (tree menu → Zgodovina sprememb …). Each entry shows exactly what changed (Rojstvo: 1950 → 14. 4. 1950), and editors can undo it (Razveljavi): edits, added or removed relationships (with marriage details), couple details, new and deleted people, gallery edits and tree renames. An undo only changes back what is still as that entry left it – fields someone edited again since are kept, and the app says so. Every person's details also have their own Zgodovina sprememb at the bottom. Typing in one person is logged as one entry per 10 minutes.
  • Admins only: deleting whole trees, importing, and removing things from the bin permanently.
  • Ključi za prijavo (passkeys): in the user menu, everyone can add a key for the device they're on, then sign in on the login screen with Prijava s ključem – fingerprint, face or the device's PIN instead of an e-mailed code (which stays as the way in elsewhere). Keys can be named and removed; a removed one signs in no more. Passkeys need HTTPS and belong to one address: with APP_URL set, that one (else the address in the browser). The device must check who holds it (fingerprint, face or PIN – a touch alone is not enough). Verified with Node's own crypto (ES256, RS256, EdDSA); no attestation is asked for.
  • Prijave in naprave: the user menu lists where you are signed in – the device ("iPhone · Safari"), when you signed in, when it was last used – and signs out any other device, or all of them. Admins sign a user out everywhere from Uporabniki (Odjavi z vseh naprav) and see Zadnje prijave in neuspeli poskusi: the last 30 days of sign-ins and failed attempts (unknown address, wrong or expired code, invalid key), with device and address. The log keeps 90 days, 5000 entries at most.
  • Editing is a right you grant: new users can only look (Samo ogled): they browse the tree, table, gallery and change log and can export, but can't change anything – the server refuses it and the interface hides the editing controls and says why. Choose Lahko ureja for someone in Uporabniki to let them edit; it takes effect within a minute, without signing in again. Their edits can be narrowed to chosen trees (Le izbrana): such an editor changes only those (everything else stays read-only for them) and can't create new trees. Adding someone with Pošlji povabilo po e-pošti ticked (the default) e-mails them the link and how to sign in; Pošlji povabilo sends it again. Set APP_URL if the link should differ from the address you use.
  • Uporabniki (admins): the users on the left – searchable, each with a badge for what they may do (Skrbnik, Ureja, Ogled) – and the chosen one on the right: their name and e-mail address, their rights (Samo ogled, Lahko ureja in all trees or chosen ones, Skrbnik, each explained), who they are in the trees (To sem jaz), and Pošlji povabilo, Odjavi z vseh naprav and Odstrani uporabnika. Changes are saved together (Shrani spremembe); leaving a user with changes not saved asks first. A changed address is the one they sign in with from then on (they stay signed in). Addresses from ADMIN_EMAIL keep their address and admin right and can't be removed. On a phone the list and the user take turns.
  • Izbriši naslove / opise fotografij (admins): user menu → Izbriši naslove fotografij … or Izbriši opise fotografij … takes the title, or the description, away from every photo in all trees (the recycle bin's too) – for words a program wrote that say little. It first asks, saying how many photos it concerns; everything else about the photos stays (a photo without a title shows as Brez naslova and can be named anew). It can't be undone in the app (the old words remain in the backups, below); each tree's change log notes it.
  • Moj račun: everyone, read-only users too, sets the name they go by (user menu → Moj račun). A new name – yours, or one an admin gives – shows with everything that person wrote: posts, comments, memories, questions and answers, guesses, gatherings and replies, older ones too; the change log keeps names as they were, Novice names who did what as they are called now.
  • Suggest a correction: read-only users have Predlagaj popravek … in a person's details – a copy of the fields to correct, plus a message (od kod to veš). Editors see N predlogov in the top bar and accept (applied as an ordinary, undoable edit, credited in the change log) or reject each one. Proposers see what became of theirs.
  • Deli za ogled (share links): editors make a link to the open tree for relatives who aren't on the user list (tree menu → Deli za ogled …): valid 7 days to a year or until removed, optionally starting at the selected person, with a note for whom. Whoever has the link sees the tree without signing in, read-only: the living appear only as Živeča oseba in their place in the family (no name, dates, places, photo or notes); the deceased with their names, dates, places, notes, life events and portraits. Documents, memories, sources and the gallery are not shown. Each link shows how often it was opened and can be removed at once; search engines are told not to index it, and an address that tries too many links that don't work has to wait.
  • Spominska stran (memorial page): in the details of someone who has died, ⋯ → Spominska stran … (or Kaj deliš → Spominska stran in Deli za ogled) makes a link to a quiet page of that one person – portrait, life story, life events, the photos they are in (only those with no living person tagged), what the family remembers (recordings play there; authors by name, never an e-mail) and their relatives who died too. If the person turns out to be living after all, the link shows nothing more. Nothing else of the tree, and the living not at all. It is a share link like the others: same durations, note, open count and removal, at /m/<token>.
  • Privacy of living people: whoever can't edit a tree (read-only users, editors of other trees) sees living people's birth, marriage and event dates as years only and none of their documents – in the app, in exports (JSON and GEDCOM) and in the change log, which shows them no old values. Living means no death recorded and born within the last 105 years (or no known birth year). Editors and admins see everything.
  • Kaj je novega: when others changed something in the open tree since your previous visit (a visit ends after half an hour away), the top bar shows N novosti: the list of those changes (as in the change log, with undo for editors), and a novo tab on the cards of the people concerned until you click Vse sem videl/-a. There you can also switch on a weekly e-mail (Mondays from 7:00) with what others changed in all trees during the past week – read-only users get it without old values, like the change log – and how many faces on the photos still wait for a name. It opens with the family's gatherings of the next two months (Srečanja, ki prihajajo – day, time, place and how many come) and what others posted in Novice that week (Objave v preteklem tednu – who, the words, whether with a photo and how many comments; these, their hearts and comments, and gatherings' answers are not listed again among the changes), then a Fotografija tedna (inside the e-mail, as an attachment it shows – the photos are never made public) with its title, date, place and who is on it, and a Spomin tedna, picked from a tree that changed; everyone gets the same ones that week, and other ones the next. A week with no changes still brings the e-mail when a gathering is less than two weeks away.
  • Light on the network: the server compresses its answers (Brotli or gzip, with Node's own zlib) – a 3,000-person tree goes from about 1 MB to about a tenth of that after each edit – and the app's own files. Background refreshes that bring nothing new cost a few hundred bytes (304).
  • Always current: when the tab comes back into view or gets focus, and every minute while you're looking, the app reloads the open tree in the background, so other people's changes show up without a reload. What you're typing is never overwritten.
  • Two people editing the same person: each save carries what the field said when you began, and the server refuses to overwrite a field someone else changed in the meantime – the rest of your changes are saved. Under that field you see their version, who wrote it (or that it was you in another window), and choose: Obdrži svojo, Prevzemi to, or for notes Združi obe (theirs, then yours). Until you choose, your text stays in the field and isn't saved over theirs. The life story's window does the same: saving after someone else changed it says so, and saving again replaces theirs knowingly.
  • When the connection drops: details save as you type; a save that can't reach the server (offline, the NAS restarting, the session ended) keeps your change in the form, says it's waiting (Shrani se, ko bo strežnik dosegljiv), and is sent again by itself – every 15 seconds, when the connection is back, and before the page is hidden; leaving the page with changes not yet saved asks first. Signing in again after a session ended keeps the page and what you typed. Requests give up after 30 seconds instead of holding up the rest. When a new version is installed on the server, an open page offers Osveži (reload); during an update the installed app starts from its kept files, and if it can't start at all it says so with Poskusi znova.
  • Kraji (Drevo → Kraji): where the family was born, lived, married and died, on a map. The server looks up each place name once with OpenStreetMap's Nominatim (only the name is sent, at most once a second, identified as HeritageTree with your APP_URL) and keeps the coordinates; the map tiles load from OpenStreetMap, which gets the site's address (never a path) as its usage policy requires. Markers show how many things happened there and, when clicked, who and what (links open the person). Do leta shows the places up to a year, and ▶ Predvajaj plays the years through. Selitve draws who moved from where to where – each person's places in the order of their life (birth, residences, emigration and other dated events, unions, death), thicker lines where more people made the same move, arrows pointing the way; click a line for who. Editors drag a wrong marker to the right spot, or pick a place that wasn't found in the list and click the map.
  • Historical place names: registers and old documents often name places as they were called before 1918 – Marburg a. d. Drau, Pettau, Cilli, Laibach, Rudolfswert, Windischfeistritz, Muraszombat (about 80 German, Hungarian and Italian names in public/js/historic-places.js). Written that way, a place counts as the place it is today: the map shows Maribor (Marburg a. d. Drau) as one place and looks it up as Maribor (not Marburg in Hesse), the Matricula link searches Ptuj for Pettau, the details show Pettau (danes Ptuj), and the table filter finds people born in Ptuj whether you type Ptuj or Pettau. Only names that mean one place are listed; a qualifier after the name (an der Drau, in Krain, , Steiermark) is fine.
  • The look: Prlekija between 1800 and 1950 as its own papers kept it – the parish registers, the almanacs (pratika), the family books and the photographers' cabinet cards – quiet enough that the app stays easy to use. Headings, names and labels are set in Old Standard, a revival of the type Austro-Hungarian and Slovene printers used from the 1850s to the 1930s; everything else, down to the buttons, in Brygada 1918, a Central European book type cut in 1918 and revived from its matrices, sturdier at small sizes. Both are served by the app itself from public/fonts, cut down to Latin letters (SIL Open Font License); what is written by hand – names on the linden, captions in the album – is in the device's own script (Snell Roundhand on a Mac or iPhone, Segoe Script on Windows), scaled to read the same size. Aged laid paper and iron-gall ink, the green of the vineyards as the accent, and nearly square corners, as things set on paper have; a printer's double rule under the top bar, and under the open place in it, as a book's running head; a vine-leaf fleuron opening Domov, whose Na današnji dan gives the date as a pratika did, in the old Slovene months, with the day's feast on the fixed feast days (1. listopada 2026 · Vsi sveti); the light of the room over the pages, the paper darkening towards its edges; years in the signs of the registers (* 1888 † 1962), which screen readers hear in words; labels in spaced capitals; the table ruled in faded red like a register; anniversaries as in a pratika, name days (saints' feasts) as red-letter days; photos as old prints on a cream mount with a pressed keyline, and the gallery as a page of an album – each print a little off true, held by paper corners, its title and date written under it, coming up as it first loads like a print in the developer, and the photo viewer a print on its mount on a walnut table (on a phone the photo stays edge to edge); a person opens as a page of a family book – the facts, life story and memories on the left, family and photos on the right, on a phone one after the other – with the form behind Uredi podatke, which on a computer stays open from person to person until Končano; the tree's cards as cabinet cards, and whoever has no photo a monogram in an oval; forms as lines to write on and longer text as ruled paper; the news as entries in a family chronicle, on the page itself; the memorial page as an osmrtnica – a black ruled frame under a cross, the portrait in an oval as on a gravestone, born (*) and died (†) as the registers wrote it. The mark and app icon are a drevo življenja, tulips growing from a vase as on painted chests, and greeting cards keep a cross-stitched border, as a voščilnica would. Dark is lit as by an oil lamp: warm browns, a glow over the page, and the album's pages black. Contrast stays at WCAG AA in both.
  • Videz: the moon (or sun) next to your avatar switches between light and dark in one click; the user menu has Samodejno (as the system says), Svetlo or Temno, and Večje besedilo – the details, dialogs, menus, Domov and the table 15 % larger (the chart, timeline and photo viewer zoom by themselves). Remembered in this browser, and applied before the page is drawn, so it never flashes the other colours.
  • Predstavitev and shortcuts: the first time the app opens with a family in it, a short tour lights up its main parts one by one – the views, the tree menu, search, a person's card, the whole tree and the fan, light or dark, the user menu – and says what each is for (steps whose part isn't on screen are left out; Preskoči or Escape ends it, and it isn't shown again in that browser). Predstavitev aplikacije in the user menu takes it again. ? (or Bližnjice na tipkovnici in the user menu) lists the keyboard shortcuts: / or Ctrl/⌘ K to search, the arrows, Enter, + − 0 in the tree, the photo viewer's and the story's keys.
  • Accessibility: checked with axe-core (WCAG 2.1 AA) in light and dark mode, and kept so by the browser tests. Text reaches 4.5:1 contrast on every surface; Preskoči na vsebino (the first Tab stop) jumps past the top bar; the views are inside one main landmark; tree cards are named by what they show (a shortened middle name is read in full); avatar initials are decoration, not labels; toasts are announced; dialogs keep focus and return it; everything works with the keyboard (arrow keys walk the tree, Enter opens the details), and movement stops for those who ask their system for reduced motion.
  • Kako sta v sorodu?: ⋯ → Kako je v sorodu z … in a person's details – pick anyone else and see the relationship in words (Stanko Horvat je pradedek osebe Nika Bratuša), the chain of people between them (blood relatives preferred over in-laws), and Pokaži v drevesu, which highlights that chain in amber in the whole tree until you close the banner.
  • Očetova in materina linija: two links at the bottom of a person's details highlight, in the whole tree, the line their surname came down (the earliest known ancestor along fathers, and everyone born to a man of that line) or the maternal line (along mothers, and everyone born to a woman of it). Parents by birth only.
  • Obletnice (tree menu): the next 31 days in the open tree – birthdays of the living (with the age they turn), godovi (name days of the living, for about 180 common Slovenian names and their variants, by the saint's feast in the Catholic calendar – Anton on 13 June, Ema on Hema Krška's day …), death and wedding anniversaries, and round birth jubilees of the deceased (100 let od rojstva). Only dates with day and month count. The switch at the bottom subscribes you to a monthly e-mail with the month's anniversaries across all trees (sent on the 1st from 7:00; read-only users don't get living people's birthdays). Set APP_URL so the e-mail links back to the app.
  • Obletnice v koledarju: Ustvari povezavo za koledar (in Obletnice) gives you a private link to subscribe to in Google Calendar, Apple Calendar or Outlook – the anniversaries and name days of all trees for the coming year, each with its count (41. rojstni dan), and the family's gatherings, refreshed by the calendar app daily and private like the app (read-only users get no birthdays of the living). Calendar apps can't sign in, so the link is the key: Nova povezava replaces it (the old one stops working), Izklopi removes it. With APP_URL set, the link uses that address.
  • Kdo je kdo? (tree menu): a game for family gatherings – a face (a portrait, or one cut from a gallery photo it is tagged on) and four names to choose from, the hard ones first (the same gender, the nearest in age); for someone who has said who they are in the tree, every third round asks Kdo ti je to? with relation words. The answer comes at once with who it was (Janez Novak · 1930 – 1995 · Za tebe: oče), and the score at the end. Keys 1–4 answer. It needs at least four faces.
  • Statistika (tree menu): the open tree in numbers – people, the living, generations, average lifespan and the earliest birth; births by decade; the most common surnames (by birth), given names and birthplaces; lifespan by century of birth; the longest lives and the oldest living; families and the one with the most children. Names open the person.
  • Priimki (tree menu → Priimki …): every surname in the tree, the most borne first, with its other spellings together (Bratuša, tudi Bratusch – by sound), how many bear it, the years they span and where those born with it were born. Open one to see its earliest known bearer, who was born with it and who came to it by marriage (Po poroki), each with the hint that tells them apart. A filter finds a surname in a big tree; names open the person.
  • Preverjanje podatkov (tree menu, editors): likely mistakes in the open tree – possible duplicates (with a button straight into merging), dates in the future, death before birth, a child born over a year after a parent died, a parent younger than 12 or older than 70 at a birth (parents by birth only), someone born 110+ years ago without a recorded death, people linked to no one, DNA matches that don't fit the tree, and a child with only one parent recorded whose parent has one partner (Je drugi morda …? – Dodaj kot starša links them, so the child's line comes from the couple). Names open the person. + Naloga turns any finding into a research to-do.
  • Naloge (research to-dos, editors): a to-do list per person – Poišči krstni list v Matriculi, Vprašaj teto Ano o selitvi – ticked off in the details, with who wrote it and who did it. The details also offer what is still unknown as to-dos in one click (Kaj še manjka: date or place of birth or death, parents, a source for the birth, the date of a marriage). Tree menu → Naloge … lists the open ones of the whole tree by person (Pokaži opravljene shows the rest). They are working notes: kept out of the change log, read-only views, share links and exports.
  • DNA (matches, editors): in the details of someone who took a DNA test, + Dodaj ujemanje DNA records a match – someone in the tree (picked as you type) or just a name, the shared cM, segments, where (MyHeritage, Ancestry …) and a note. While you type, the dialog lists what that amount likely means (1C1R – bratranec/sestrična, 1 rod narazen, with the expected range) and, for someone in the tree, how the tree relates them and whether the amount fits (by the Shared cM Project 4.0 ranges; only parents by birth count, and endogamy or several lines at once are not accounted for). A match that doesn't fit shows in red on both people and in Preverjanje podatkov (DNA se ne ujema z drevesom), where it can become a to-do. Genetic data is sensitive, so matches are for editors only – out of the change log, read-only views, share links and exports.
  • Merge duplicates: ⋯ → Združi z drugim zapisom … in a person's details: pick the other record (likely duplicates – same name, matching or missing birth year – are suggested), choose per field which value stays (the more precise date is preselected; notes can be combined), and confirm. Parents (with their kind), partners (with marriage details), children, photo, gallery tags, events, documents and To sem jaz move to the kept person; the other record goes to the bin. If the links don't fit (a third parent, an ancestor merged with a descendant), nothing changes.
  • Spomini (memories): everyone, read-only users included, can Zapiši spomin about a person – a few words, a photo, and a voice recording made right there with the microphone (grandma telling a story; recording needs HTTPS) or picked as a sound file (WebM, Ogg, MP4/M4A, MP3, WAV, up to 60 MB). Memories show in the person's details with a player, in the change log and in the family book. Their author can change or remove them, and so can editors of the tree. Someone who can't edit the tree has an allowance of 500 MB for memories' recordings and photos in all, and up to 30 new memories an hour, so nobody can fill the NAS by accident. Everyone with access sees them. JSON exports keep the words; photos and recordings stay in data/originals/.
  • Memories of a photo: under a photo in the gallery viewer, Kaj veš o tej fotografiji? writes a memory of the photo itself – who took it, where, on what occasion – with words, a recording and a picture, exactly as memories of people (same rights, allowance and bin). They show under the photo with a player, and among Domov's newest memories, where a click opens the photo. They follow the photo into the bin and out, and travel with it in JSON exports.
  • Pošlji (sending): Pošlji … in the photo viewer sends the photo through the phone's share sheet (Viber, WhatsApp, e-mail …), or downloads it where the browser has none for files. On Domov and in Obletnice, a birthday, name day or wedding anniversary of the living has Voščilo: a greeting card made right there – the newest photo of them (cut around their faces) or a portrait, Vse najboljše za 36. rojstni dan, Živa!, the date and the tree's name, on warm paper (1080 × 1350, as messengers show photos) – shown first, then sent the same way.
  • The photo viewer: the photo on the left and a panel beside it (below it on a phone) with the title, date and place, the heart, who is on it, the description, then Komentarji and Spomini, and at the end the buttons (Pošlji, Neznan obraz, Označi osebe, Uredi …). The box to write a comment in stays at the foot of the panel; 💬 3 komentarji under the title jumps to them. On a computer the panel can be hidden for the photo alone (the button at its top right; remembered on the device). Editors rename a photo right there: ✎ beside its title turns it into a box – Enter saves, Escape leaves it as it was.
  • Novice (the family wall): on Domov, what the family posts among what else they did, newest first (Starejše objave for more): photos added to the gallery (those one person added at a sitting as one item, four shown and +8), memories written, questions asked (with Odgovori) and answered, comments on photos and faces recognised – each leading on to the person, photo or question; what was removed since is left out. Today's birthdays, name days and anniversaries sit on top, with Voščilo. Anyone with access, read-only users too, posts a few words and a photo – Kaj je novega, Dušan? – as on Facebook (on a phone or tablet Kamera takes the photo right there, with the back camera; a computer has only Fotografija): typing @ and the start of a name brings up the people of the tree it matches (with nothing typed yet, your closest relatives; @ Omeni does the same), and the one picked shows in the post as their name, leading to them; whom a post mentions is whom it is about. Mentions work in comments too, under posts and under photos. They keep the person's id beside the name as written, so a renamed person shows under their new name, and merges and imports follow the person; e-mails and the change log show the names alone. Whoever is mentioned – the relative who said they are that person (To sem jaz) – gets an e-mail with what was written and where (a post, a comment under a post or a photo) and a link to the tree: at most one an hour with everything since the one before, only what still names them (not deleted or edited away meanwhile), never their own words; Moj račun switches it off (on by default, and switched back on it starts from then). Those who follow a person (Spremljaj) find mentions of them in their follow e-mail. Posts show with how many liked and commented, Všeč mi je and Komentiraj across the card, and the comments (the newest two, Prikaži vse komentarje for the rest; Enter posts a comment). The ⋯ of a post lets its author or an editor change it (words, people, photo) or delete it – to the bin, with Razveljavi right after. A post's photo stays with the post (shrunk to 1600 px in the browser; 500 MB per relative without editing rights, a post's photo at most 8 MB). An editor's photo can go to the gallery too – Dodaj tudi v galerijo when posting (ticked by default), or Shrani v galerijo later – and then opens there, with its faces, memories and comments. Someone who can't edit the tree posts up to 20 times an hour. Posts never show on share links or memorial pages; they show in the change log, move with a merge and travel in JSON exports (without their photos).
  • Srečanja (gatherings): on Domov, + Novo srečanje calls the family together – what, the day (and perhaps the time), where and a few words. Anyone with access calls one, read-only users too (up to 10 an hour without editing rights), and everyone answers Pridem, Morda or Ne pridem (pressed again, taken back; changed the same day, the change log keeps only the last). Domov lists those ahead, soonest first, with who comes (Pridejo: Teta, Ana in ti · Morda: Vnuk); Novice tells when one was called, with the same answers; the organizer sees who answers in Zate. Its organizer or an editor changes it (✎) or deletes it – to the bin, answers and all, with Razveljavi. Gatherings are in the calendar link too (Ustvari povezavo za koledar in Obletnice) – at their time, or all day. The tree keeps showing them for two months after; they are not part of JSON exports.
  • Zate (for you): beside Vse above Novice, Zate shows only what others did that concerns you in the open tree – comments and hearts on your posts, on the photos you added and on your memories, answers to your questions, who comes to the gatherings you called, posts and comments that mention you and your face recognised on a photo (once you said which person you are, To sem jaz). A post shows once, with everything on it. How many came since you last looked shows as a red number on the Domov button (and next to Zate) – checked when the tree opens and every minute with the rest – until you open Zate. When you looked is kept on the server, so it is the same on every device.
  • Comments on photos: under every photo in the viewer, Komentarji – anyone with access, read-only users too, writes one (Enter posts, Shift+Enter starts a new line; a few dozen an hour without editing rights); its author or an editor removes it. The tile shows how many (💬 3). Comments show in Kaj je novega and the weekly e-mail, go to the bin with their photo, and travel in JSON exports.
  • Hearts: everyone with access, read-only users too, can give a photo (in the viewer) or a memory (in a person's details or under a photo) a ♥, and take it back. The count shows on the photo's tile and next to the button; resting on it says who (♥ ti, Ana in še 3). A heart shows in Kaj je novega, the change log and the weekly e-mail; taken back the same day, it leaves no entry.
  • Predvajanje (slideshow): ▶ Predvajaj in the gallery plays its photos full screen, oldest first – each fading into the next and drawing slowly nearer to the faces tagged on it (or its middle), with its title, date and who is on it. A person's details play their photos (▶ Predvajaj) or those of the whole branch below them – them and everyone descended from them (▶ Z vso vejo potomcev). It plays by itself and starts over at the end; ‹ › or the arrow keys, a swipe, and space (pause) steer it; the controls fade while nobody moves the mouse, the screen stays on, and Escape ends it. With reduced motion set, the photos only fade.
  • Spominski intervju: 🎙 Intervju … under a person's memories asks them twenty questions one at a time – where they were born, the home they grew up in, their parents, school, holidays, work, how they met their partner, the war, family stories, what they want the grandchildren to know – worded for them (Kje si odraščala?). Record the answer (and write a few words if you like), Shrani in naprej: each answer is saved as a memory with its question, and questions already answered for them are left out next time.
  • Vprašanja (questions): anyone with access, read-only users too, can Vprašaj družino about a person ("Kje je ded delal pred vojno?") and others Odgovori – a short thread under the person's details. Domov lists the questions still open, so relatives see what they might know. Answers by others show in Kaj je novega and the weekly e-mail. The asker or an editor marks a question answered (✓, ↺ opens it again) or removes it – to the bin, answers and all; an answer's author or an editor removes the answer. Someone who can't edit the tree asks and answers up to 30 times an hour. Questions move with a merge and travel in JSON exports.
  • Spremljaj (follow): the bell in a person's details follows them – read-only users too. When others change or add something about them (details, relatives, life events, documents, memories, questions and answers, a photo they are newly tagged in, a post or comment that mentions them), an e-mail tells you, with a link to them: at most one an hour, with everything since the previous one, worded as your change log shows it. Ring the bell again to stop.
  • Življenjepis (life story): each person's details open with their life told in sentences from the tree – birth, parents, siblings, work, moves, marriages, children, death (Franc Bratuša se je rodil 14. 4. 1925 v kraju Ptuj. … Umrl je leta 1999 v kraju Maribor, star 74 let.), in Slovene or English, verbs agreeing with the person's gender and names kept in the nominative so nothing has to be declined. Editors can Zapiši po svoje … – start from that text and rewrite it – or go back to the told one. It also opens each page of the family book and the story slideshow. Read-only users see the told version of the living (with years only), never a written one, which might hold full dates.
  • Zgodba (story): the ▶ button in a person's details tells their life as a full-screen slideshow – who they were, then their birth, life events, partners and children with the photos they are in, in the order of the years (a photo from before the birth comes before it), the death, what the family remembers (recordings play) and a last slide with their children and grandchildren. Arrow keys, swipes or the buttons move through it; Predvajaj moves on every 7 seconds and waits for a recording to finish. It is always dark, like a cinema, and keeps still for those who ask their system for reduced motion.
  • Life story, sources and documents: each person's details show their Življenjska pot – birth, life events, marriages, children's births and death in order. Events (Bivališče, Poklic, Šolanje, Krst, Vojaška služba, Izselitev, Pokop, Drugo) have a date, place, description and a source (Vir: a register, a letter, grandma's story …), and can be edited and undone. Dokumenti in viri holds documents – a birth or baptism record, a marriage or death record, a census, a letter … – each with all its scans as pages in order (PDFs and pictures, up to 100 MB a page, kept as uploaded next to the gallery originals in data/originals/); picking several files at once makes them the pages of one document. A document opens in an overlay: the page large, a click to zoom into a scan, arrows or the numbered strip for the other pages, and beside it its kind, date, place and a transcription. See docs/documents.md. Events are part of exports and GEDCOM (BAPM, RESI, OCCU, EDUC, EMIG, BURI, typed EVEN, with SOUR); document files are not.
  • Poišči v arhivih: each person's details link to searches for them on FamilySearch (name, birth year ± 2, birthplace), MyHeritage and Geni, and – when a birth or death place is known – to that place's scanned parish registers on Matricula (Slovenian dioceses included). Each opens in a new tab; nothing is sent until you click.
  • Viri (sources): a register, a letter, a book or grandma's account is recorded once per tree (title, where it is kept, a link, a note – tree menu → Viri …, which also lists who cites each one) and cited from what it confirms about a person: them in general, their birth, death, a life event or a marriage, with the page or entry (+ Navedi vir in Dokumenti in viri; a new source can be written right there). Citations show under the fact in the person's Življenjska pot and in the family book. A deleted source goes to the bin and comes back with its citations; deleting an event takes its citations along; a removed citation can be undone in the change log. JSON exports and GEDCOM keep them (GEDCOM: SOUR and REPO records, cited with PAGE under BIRT, DEAT, the events and MARR), and GEDCOM files from other programs bring their sources in the same way. The free-text Vir of an event stays as it was.
  • Adoption, fostering, step-parents: a parent can be a parent by birth (default), adoptive (posvojitelj), foster (rejnik) or a step-parent (očim/mačeha) – choose it when adding a parent or child, or with ✎ next to them in the family list. Labels follow (posvojenka, pastorek …), the line to such a child is dotted, and exports keep it (GEDCOM: adoptive and foster as PEDI). A person still has at most two parents.
  • Marriages: next to each partner in the details panel, the pencil records the union. Choose Zakon (marriage) or Partnerska zveza (partnership), the date and place, and whether and when it ended. Labels follow from it (žena, bivši mož, …), ended unions are drawn with a dashed line, and everything is included in exports.
  • Removing a link: × next to a parent, partner or child in the details removes that link (Razveljavi in the message, or the change log, brings it back). Two people with a child together are a couple through it, so removing a partner says which children they share and takes the partner off as their parent too – the children stay with the person whose details are open; undo restores the children's links and the marriage details as well.
  • To sem jaz: everyone (guests too) can mark which person in a tree they are. The tree then opens on you, your card carries a small ti, every other card a tab with who that person is to you (dedek, teta, sestrična), the table measures relationships from you, and every person's panel says how they are related to you (Sorodstvo s tabo: sestrična). Each person can belong to one account only.
  • Who they are to you, everywhere: once you are in the tree, Domov's lists and the anniversaries show beside each name who that person is to you (Maja Novak sestra), and when more anniversaries are coming than Domov has room for, those of your closest family are the ones shown.
  • First arrival: someone who opens a tree they have not said they are in is asked who they are, before the tour – a short list of whom their name (or e-mail) suggests, then the youngest living people nobody has claimed, and a search. Picking oneself opens the tree on them with the relation tabs on every card. Pozneje asks again next time; Nisem v drevesu (or having picked) asks no more in that browser.
  • Personal invitations (admins): Povabi … in a living person's details sends their relative an e-mail – »Ana« te vabi v družinsko drevo …, kot Živa Novak – with a link that signs them in with one click (Vstopi v drevo) and opens the tree on that person, already To sem jaz, with the relation tabs on every card. A new address becomes a read-only user (or an editor, if ticked); an existing user keeps their rights. The link works once and for 30 days (only its SHA-256 is stored, and the token after # never reaches a server log); inviting again sends a new one and the old stops working. Afterwards they sign in with their address and a code as usual. The sign-in log shows povezava iz povabila.
  • Person details: a window (modal) with the form and the family side by side; edits save automatically, also when you close it. Clicking a relative inside moves to them, and ← goes back the same way. The button next to ✕ switches to a side panel instead (remembered per browser), where the first click selects a person and a second opens the panel. Family members are listed as links, and removing a relationship can be undone.
  • As an app on the phone: HeritageTree can be installed – on Android/Chrome/Edge via Namesti kot aplikacijo in the user menu (or the browser's install button), on iPhone via Share → Add to Home Screen (an iPhone or iPad says how, once). It then opens full screen with its own icon, the status bar in the colour of the top bar (light or dark, as Videz is set); a long press on the icon offers Novice, Galerija and Dodaj fotografijo, in the tree used last. On Android, the installed app is also in the share sheet: share one or more photos from the phone's gallery (or Google Photos) to HeritageTree, and they open in Dodaj več fotografij of the tree you used last – titles and dates taken from the files, as when picked by hand (editors; iPhones don't offer this to web apps). A small service worker keeps the app's own files – from the first visit – so it starts quickly: the page itself is asked of the server each time and says which version of the app it is; of the version kept, its hundred-odd scripts come from the device at once instead of each being checked with the server (on a phone that was a few seconds at every start), and after an update the old copy goes and the new files are fetched and kept, so updates still show at once. On a weak signal the start waits four seconds for the server, then opens from the kept files (all of one version) and fetches the current ones for next time.
  • Smooth movement: switching views (Domov, Drevo, Galerija, the tree's Tabela, Časovnica …) is a short cross-fade with the top bar staying put (none with reduced motion). On touch screens, pulling Domov, the gallery or the table down from the top loads the tree anew – the installed app has no browser around it to do that.
  • Na voljo brez povezave (user menu, per device): with it on – by default in the installed app, off in a browser tab – the device keeps what the app last read (the tree, the gallery and its lists, portraits and thumbnails, fetched ahead after each visit; never original files, documents or recordings). Without a network the app then opens from that, with a note saying from when (Brez povezave – prikazano je, kar je bilo shranjeno …); changes wait and are saved once the connection is back. Switching it off, signing out, or losing access deletes everything kept.
  • English interface: the switch in the user menu (and on the sign-in screen) changes the language for that browser and for the account: everything on screen – kinship terms included (first cousin once removed, mother-in-law, stepson), the server's messages, and the sign-in, invitation, monthly and weekly e-mails and the calendar. What people typed (names, dates such as okoli 1920, notes) stays as written. Tests check that every text has both languages.
  • Search (/ or ⌘K) ignores accents and also matches birth years.
  • Light and dark mode. On phones the panel turns into a bottom sheet.
  • The server checks every relationship: at most two parents per person, nobody can be their own ancestor, relationships never cross trees, and an add either fully succeeds or changes nothing.

Run locally

Requires Node.js 24 or newer (it uses the built-in node:sqlite).

npm install
cp .env.example .env   # set ADMIN_EMAIL; leave SMTP empty to get codes in the log
npm run dev            # http://localhost:3000, restarts on changes
npm test

Browser tests (development only – Playwright isn't part of the app or its Docker image): the real app in Chromium, against a test server with an in-memory database (e2e/serve.js) – signing in, building a family, editing, what read-only users see, the English interface, share links, Domov, big trees, the timeline and statistics, every tool opening without an error, the tour and shortcuts, removing a partner (with a child together) and undoing it, a save made offline that is kept and sent when the server is back, and two people changing the same field. e2e/a11y.spec.js runs axe-core (WCAG 2.1 A and AA) over every view, the main dialogs (Priimki, the tour and the shortcuts too), the phone layout (its bars, the person and photo sheets, a window), the sign-in page, a share link and a memorial page with a photo, in light and dark. e2e/mobile.spec.js uses the app as a phone does (375 × 812, touch): what fits the screen, swipes and held fingers, sizes for a fingertip, typing, menus and windows, a phone held sideways, and the installed app. Once, install Playwright's browser, then run them:

npx playwright install chromium
npm run test:e2e

Data goes to ./data/heritage.db unless you set DATABASE_FILE. Set PORT to change the port.

Deploy on Synology

The NAS runs the app from a git checkout of this repository. The data lives outside it:

/volume1/Share/DockerCompose/heritage-tree/   git checkout + your .env (not in git)
/volume2/docker/heritage-tree/data/           database, photos and originals/ (mounted as /data)

First setup (SSH, with the Git Server package installed so git is available):

cd /volume1/Share/DockerCompose
sudo git clone https://scm.hanodrim.com/dusan.bratusa/heritage-tree.git
sudo cp /path/to/your/.env heritage-tree/.env
cd heritage-tree && sudo docker compose up -d --build

Updates: sudo sh /volume1/Share/DockerCompose/heritage-tree/update.sh. When git has a new version it lists what is new, pulls, rebuilds and restarts; with nothing new it says so and leaves the running app alone (--force rebuilds anyway, e.g. after changing .env). The data stays untouched. Database upgrades run on start.

  • The app listens on NAS port 30000 for the home network (plain HTTP); from outside, only HTTPS through the reverse proxy. Don't forward port 30000 on the router.
  • The container takes ownership of data/ on start, so the folder needs no special permissions.
  • Certificate: Control Panel → Security → Certificate → Add → Get a certificate from Let's Encrypt for your hostname (needs port 80 forwarded to the NAS).
  • Reverse proxy: Control Panel → Login Portal → Advanced → Reverse Proxy. Make two rules for your hostname, both with destination HTTP, 127.0.0.1, port 30000, and the custom header X-Forwarded-Proto = $scheme:
    • Source HTTPS port 443, with HSTS enabled. Assign the certificate to this rule under Certificate → Settings.
    • Source HTTP port 80. The app redirects these visits to HTTPS, while DSM still answers Let's Encrypt's renewal checks itself.

Moving your data to the Synology

Either way works; both keep everything, photos included:

  1. Export / import (simplest): here, open the tree menu → Izvozi vsa drevesa. On the Synology, the first screen offers uvozi drevesa iz izvozne datoteke; pick the file. Later imports go through the tree menu → Uvozi iz datoteke ….
  2. Copy the database: stop the app, then copy data/heritage.db into the NAS's data folder before the container's first start. Copy heritage.db-wal too if it exists. Any older database is upgraded automatically when the app starts.

Varnostne kopije (in the app, admins): user menu → Varnostne kopije … lists the daily snapshots to download one by one, and Prenesi celotno kopijo downloads everything as one .tar file – a fresh snapshot of the database plus every original file (gallery scans, documents, memories' recordings and photos) and a PREBERI.txt with the restore steps. Keep one on another disk or in the cloud now and then.

Backups: the app writes a consistent snapshot of the database every day to data/backups/heritage-YYYY-MM-DD.db and keeps the last 14. Let Hyper Backup back up that folder rather than the live heritage.db; copying the live database file can catch it mid-write. Back up data/originals/ as well: it holds the untouched gallery files, documents and memories' recordings, which the database snapshots don't contain (each file there is written once and never changed, so copying it any time is safe). Schema upgrades run automatically when the app starts, so existing data carries over when you update the image.

To restore a backup:

  1. Stop the container.
  2. Copy the chosen data/backups/heritage-….db over data/heritage.db.
  3. Delete data/heritage.db-wal and data/heritage.db-shm if they exist.
  4. Start the container again.

Sign-in and users

Only addresses on the user list can sign in. They enter their e-mail and receive a 6-digit code that is valid for 10 minutes. Everyone who is signed in sees every tree. Only users with the editing right (Lahko ureja) change them – new users start without it – and admins (Skrbnik) always edit and also manage the user list (top-right menu → Uporabniki). Users who were Član before this change kept their editing right.

All configuration goes in a .env file next to the app (copy .env.example). npm run dev/npm start and Docker Compose both read it. Never commit it.

  • ADMIN_EMAIL: these addresses are always admins, even after a restart. This is also your way back in if you ever lock yourself out. The app won't start until at least one admin exists.
  • Who sends the codes: whichever mailbox you configure with SMTP_* / MAIL_FROM:
    • Simplest: a dedicated Gmail account, e.g. druzinsko.drevo@gmail.com. Turn on 2-step verification, create an App password, and use SMTP_HOST=smtp.gmail.com, SMTP_PORT=587, SMTP_USER/SMTP_PASS = that address and app password. MAIL_FROM must be the same address.
    • Own domain: a transactional mail service such as Brevo or Resend (both have free tiers and SMTP access). Codes come from e.g. drevo@your-domain.si and are less likely to land in spam.
    • Not configured yet: codes are printed to the server log ([e-mail to …] 123456 – koda …). Use this locally, or read the code from Container Manager → Log on the Synology before mail works. When SMTP is configured, the log says SMTP ready or why it failed.
  • Security:
    • Codes and session tokens are stored only as hashes.
    • A code allows 5 attempts, and you can request a new one at most once a minute (5 per hour per address, 20 per hour per IP).
    • The sign-in form answers the same way for addresses that aren't on the list, so it doesn't reveal who is.
    • Sessions live in an HttpOnly, SameSite=Lax cookie for 90 days, extended while in use. Removing a user signs them out everywhere at once.
  • Behind the Synology reverse proxy: the cookie is marked Secure when the proxy reports HTTPS. If sign-in works but the cookie lacks Secure, add the custom header X-Forwarded-Proto = $scheme to the reverse-proxy rule. TRUST_PROXY defaults to trusting private-network proxies, which covers Synology → container.

API

JSON over HTTPS under /api. A session cookie (ht_session, from signing in) is needed everywhere except where a section says otherwise; without one the answer is 401. Who may call: anyone (no session), signed in (every user, read-only ones too), editors (admins, and editors of that tree – others get 403), admins. Every change answers with what it changed – usually the whole affected tree – so the browser never reconciles partial state. Errors are { error } with a status code, in Slovenian, or in English with the header X-Lang: en. Large lists and trees are compressed (Brotli or gzip).

tree is { id, name, people, parents, partners, claims, events, documents, memories, questions, sources, citations }, plus for editors todos, dna and openSuggestions. For those who can't edit the tree it is private (private: true): living people's dates are years only, their documents and the to-dos and DNA matches are left out. A person's photo is its version (or null). Relationship type is parent, child, partner or sibling, the relative's role from personId's side; a parent's kind is birth, adoptive, foster or step.

Signing in (anyone)

Method & path Body Returns
POST /api/auth/request { email } { ok } – e-mails a 6-digit code if the address may sign in (the answer is the same either way)
POST /api/auth/verify { email, code } { user } + session cookie
POST /api/auth/passkey/options WebAuthn request options { challenge, rpId, userVerification, timeout }
POST /api/auth/passkey/verify { id, clientDataJSON, authenticatorData, signature, userHandle } (base64url) { user } + session cookie
POST /api/auth/logout { ok }
GET /api/health { ok }

You (signed in)

Method & path Body Returns
GET /api/auth/me · PATCH /api/auth/me { name?, digest?, weekly?, lang? } (lang: sl or en) { user }
POST /api/auth/me/seen { user } – Kaj je novega starts afresh
GET /api/auth/sessions { sessions: [{ id, device, created_at, last_used_at, current }] }
DELETE /api/auth/sessions/:id · POST /api/auth/sessions/sign-out-others { sessions }
GET /api/auth/passkeys · DELETE /api/auth/passkeys/:id { passkeys }
POST /api/auth/passkeys/options WebAuthn creation options
POST /api/auth/passkeys { id, clientDataJSON, authenticatorData, publicKey, publicKeyAlgorithm, name? } 201 { passkeys }
PUT /api/me/person · DELETE /api/me/person/:treeId { personId } { tree } – To sem jaz
POST /api/people/:id/invite { email, name?, canEdit? } (admins; a living person nobody is yet) { created, invited, inviteError, tree } – the user is that person and gets a one-time link
POST /api/auth/invite { token } (from #/invite/<token>) { user, treeId, personId } and a session; 410 when used or expired
GET · POST · DELETE /api/me/calendar { url } – the anniversaries calendar link (POST makes a new one, the old stops; null when off)

Users (admins)

Method & path Body Returns
GET /api/users { users }
POST /api/users { email, name?, role, invite? } (role: viewer, editor or admin) { users, invited?, inviteError? }
PATCH /api/users/:id { role?, name?, email?, editTrees? } (editTrees: null for all, or tree ids) – all or nothing { users } – each with editTrees, fixed (from ADMIN_EMAIL) and people: who they are in the trees
POST /api/users/:id/invite { users, invited?, inviteError? }
DELETE /api/users/:id · DELETE /api/users/:id/sessions { users } – removed, or signed out everywhere
GET /api/users/sign-ins { signIns: [{ at, email, ok, method, reason, ip, device, user_label }] } (30 days)

Trees, export and import (signed in; changes for editors)

Method & path Body Returns
GET /api/trees · POST /api/trees { name, rootId? } (rootId: a branch starting from that person; editors of every tree) { trees: [{ id, name, people, parentId?, rootId? }] } · 201 { tree }
GET /api/trees/:id · PATCH /api/trees/:id { name } { tree } – a branch's also has branchOf: { id, name, rootId } and links: [{ personId, parents }] (members whose parents are in the full tree, and always the person it starts from – parents may be empty); a tree with branches branches: [{ id, name, rootId }]
DELETE /api/trees/:id (admins) { trees } – the tree goes to the bin (409 while branches start in it; a branch goes without its people)
GET /api/export · GET /api/trees/:id/export an export file of all trees or one (download; private parts left out for those who can't edit)
GET /api/trees/:id/export/gedcom the tree as GEDCOM 5.5.1 (download)
GET /api/trees/:id/export/csv the tree's people as a CSV table (download)
POST /api/import export file, ≤ 250 MB (admins) 201 { imported: [{ id, name, people }], trees }
POST /api/import/gedcom raw .ged, name in X-File-Name (admins) 201 { imported, trees }
POST /api/import/csv raw .csv, name in X-File-Name (admins) 201 { imported, trees }
POST /api/trees/:id/import/preview raw .ged or .csv { token, people: [{ person, match, fills, differences }], parents, partners, sources }
POST /api/trees/:id/import/apply { token, changes? } ({ fileId: personId | null }) { tree, summary }

People and relationships (editors; photos for everyone signed in)

Method & path Body Returns
POST /api/trees/:id/people { person, relation? } (relation: { type, personId, otherParentId?, kind? }) 201 { id, tree }
PATCH /api/people/:id · DELETE /api/people/:id person fields, and optionally base: the values the edit started from { tree } (deleted: to the bin); 409 { error, conflicts: [{ field, theirs, by, you }], tree } when someone changed one of those fields since – the others are saved
POST /api/people/merge { keepId, mergeId, fields } { tree }
GET /api/people/:id/photo the image (cacheable; add ?v=<photo>)
PUT /api/people/:id/photo · DELETE raw JPEG / PNG / WebP, ≤ 2 MB { tree }
POST /api/relations { type, personId, relativeId, otherParentId?, kind? } { tree }
DELETE /api/relations { type, personId, relativeId, withChildren? } – withChildren (partners): the relative also stops being the parent of their shared children { tree, undo } (undo: the change-log entry, for POST /api/activity/:id/undo)
PATCH /api/partnerships { personA, personB, married?, start_date?, start_place?, ended?, end_date? } { tree }
PATCH /api/parents { parentId, childId, kind } { tree }

Life, documents and sources (editors; documents of the living only for them)

Method & path Body Returns
POST /api/people/:id/events · PATCH · DELETE /api/events/:id { type, date?, place?, description?, source? } { tree } (201 when added)
POST /api/people/:id/documents raw PDF or image (its first page), ≤ 100 MB; X-File-Name, X-Title? (URI-encoded) 201 { id, tree }
PATCH /api/documents/:id · DELETE { kind?, title?, date?, place?, transcription? } { tree } (deleted: to the bin)
POST /api/documents/:id/pages raw PDF or image, ≤ 100 MB; X-File-Name 201 { tree }
GET /api/documents/:id/pages/:pageId ?download=1 saves it (GET /api/documents/:id: the first page) the file
PATCH /api/documents/:id/pages/:pageId · DELETE { position } (0 is first) { tree } (removed: undo with POST …/restore; not the last page)
POST /api/trees/:id/sources · PATCH · DELETE /api/sources/:id { title, repository?, url?, note? } { tree } (201 { id, tree } when added)
POST /api/people/:id/citations · PATCH · DELETE /api/citations/:id { sourceId, fact, eventId?, partnerId?, page?, note? } (fact: general, birth, death, event, marriage) { tree }

Memories, questions and corrections (signed in, read-only users too; their author or an editor changes them)

Method & path Body Returns
POST /api/people/:id/memories · PATCH /api/memories/:id { text } 201 { id, tree } · { tree }
POST /api/gallery/:id/comments · DELETE /api/gallery/comments/:id { text } (anyone signed in; removing: its author or an editor) 201 { items } · { items } – each item's comments
PUT /api/gallery/:id/heart · DELETE (anyone signed in) { items } – each item's hearts: [{ user_id, label }]
PUT /api/memories/:id/heart · DELETE (anyone signed in) { tree } – each memory's hearts
GET /api/trees/:id/feed?before&limit (anyone signed in) – Novice: posts and the family's doings, newest first; before: the next of the previous page { items: [{ at, post } | { at, entry } | { at, user_label, photos: [itemId] }], next }
POST /api/trees/:id/gatherings · PATCH /api/gatherings/:id { title, day: 'YYYY-MM-DD', time: 'HH:MM' | '', place, note } (anyone signed in; changing: its organizer or an editor) 201 { id, tree } · { tree } – tree.gatherings: [{ id, user_id, user_label, title, day, time, place, note, replies: [{ user_id, user_label, answer }] }]
PUT /api/gatherings/:id/reply { answer: 'yes' | 'maybe' | 'no' | null } { tree }
DELETE /api/gatherings/:id · POST /api/gatherings/:id/restore { tree } – to the bin, and back
GET /api/trees/:id/for-you · POST /api/me/for-you-seen (anyone signed in) – Zate { unseen, items } (items as in the feed) · { ok }
GET /api/trees/:id/posts?beforeAt&beforeId&limit (anyone signed in) – newest first, before the post given { posts }: [{ id, user_id, user_label, text, photo, photo_width, photo_height, saved_item_id, created_at, updated_at, people, hearts, comments }]
POST /api/trees/:id/posts · PATCH /api/posts/:id { text, people } (anyone signed in; changing: its author or an editor; savedItemId: editors) 201 { post } · { post }
PUT · GET · DELETE /api/posts/:id/photo raw image (≤ 8 MB, X-Width, X-Height) { post } · the photo · { post }
DELETE /api/posts/:id · POST /api/posts/:id/restore { treeId } · { post } – to the bin, and back
POST /api/posts/:id/comments · DELETE /api/posts/comments/:id { text } 201 { post } · { post }
PUT /api/posts/:id/heart · DELETE { post }
POST /api/gallery/:id/memories { text } – a memory of a photo (then as any memory; tree.memories carry item_id instead of person_id) 201 { id, tree }
PUT /api/memories/:id/audio · PUT /api/memories/:id/photo raw audio (≤ 60 MB, X-Duration seconds) or image (≤ 8 MB) { tree }
GET · DELETE /api/memories/:id/:kind kind: audio or photo the file · { tree }
DELETE /api/memories/:id · POST /api/memories/:id/restore { tree } – to the bin, and back
POST /api/people/:id/questions · POST /api/questions/:id/answers { text } 201 { id, tree }
PATCH /api/questions/:id { answered } (the asker or an editor) { tree }
DELETE /api/questions/:id · POST /api/questions/:id/restore · DELETE /api/answers/:id { tree }
POST /api/people/:id/suggestions { fields, note? } 201 { ok }
GET /api/trees/:id/suggestions { suggestions } (editors all, others their own)
POST /api/suggestions/:id/accept · POST /api/suggestions/:id/reject (editors) { tree, suggestions }

Research to-dos and DNA matches (editors)

Method & path Body Returns
POST /api/people/:id/todos · PATCH · DELETE /api/todos/:id { text?, done? } { tree } (201 { id, tree } when added)
POST /api/people/:id/dna · PATCH · DELETE /api/dna/:id { matchId | matchName, cm, segments?, company?, note? } { tree } (201 { id, tree } when added)

Gallery (signed in; changes for editors)

Method & path Body Returns
GET /api/trees/:id/gallery · POST { title?, date?, place?, description?, people? } { items } · 201 { id, items }
PATCH /api/gallery/:id · DELETE as above { items } (deleted: to the bin)
PUT /api/gallery/:id/detected { version, faces: [{ x, y, w, h, score }] } (editors; from the face detector) { scanned, detected } – faces near a marked spot are left out
POST /api/gallery/detected/:id/identify · /ask · DELETE /api/gallery/detected/:id { personId } · – · – (editors) { items } – tagged there / a face for the relatives / dismissed
POST /api/gallery/detected/:id/restore (editors) { items } – a dismissed face waits for a name again
POST /api/gallery/detected/batch { ids, action: 'identify' | 'ask' | 'dismiss', personId? } (editors) { items, skipped } – identify places the person once a photo
PUT /api/gallery/:id/faces { personId, x?, y? } (fractions of the photo; none to remove the place) { items }
POST /api/gallery/:id/unknowns { x, y } – a face nobody knows (anyone signed in) 201 { items } (each item's unknowns: { id, x, y, user_id, user_label, created_at, guesses })
PUT /api/gallery/unknowns/:id/guess { personId } or { text } (anyone signed in; replaces their earlier guess) { items }
DELETE /api/gallery/unknowns/:id · DELETE /api/gallery/guesses/:id (who marked it / wrote it, or an editor) { items }
POST /api/gallery/unknowns/:id/identify { personId } (editors): tagged on that spot, the mark goes { items }
PUT /api/gallery/:id/images/:kind · DELETE { data, thumb, width, height, sizing } (base64 JPEG / PNG / WebP); kind: original, restored or colorized { items }
PUT /api/gallery/:id/images/:kind/source the untouched file, ≤ 100 MB; X-File-Name { items }
PUT /api/gallery/:id/images/:kind/refresh { data?, thumb, width?, height?, sizing } – the same picture at today's sizes; without data only the thumbnail { items } (the kept original stays; not in the change log)
GET /api/gallery/:id/images/:kind · GET /api/gallery/:id/images/:kind/source ?thumb=1 for the thumbnail the image (cacheable; add ?v=<version>) · the untouched file

Places (signed in; positions for editors)

Method & path Body Returns
GET /api/trees/:id/places { places: [{ name, formerly, lat, lon, status, refs }], pending }
PUT /api/places { name, lat, lon } { ok }

Change log and recycle bin (signed in; undo and restore for editors)

Method & path Body Returns
GET /api/trees/:id/activity ?person=ID, ?limit=N (≤ 300) { activity: [{ id, action, subject, subject_id, detail, user_label, undone, at }] }
GET /api/trees/:id/news { since, activity } – what others changed since your previous visit
POST /api/activity/:id/undo { treeId, skipped, tree, items, trees }
GET /api/trees/:id/trash { people, gallery, document, memory, question, source, trees } (trees for admins)
POST /api/trash/:type/:id/restore type: person, gallery, document, memory, question, source, tree (admins) { treeId, skipped, tree, items, trees }
DELETE /api/trash/:type/:id (admins) { ok }

Share links and the calendar

Method & path Body Returns
GET /api/trees/:id/shares · POST { days, personId?, label?, kind?: 'tree' | 'memorial' } (editors) { shares: [{ …, url }] } (201 when made)
DELETE /api/shares/:id (editors) { shares }
GET /api/share/:token (anyone with the link) { tree, focusId, label, expiresAt } – the living hidden; a memorial link: { memorial, label, expiresAt }
GET /api/share/:token/photos/:id · …/memories/:id/:kind (anyone with a memorial link) the person's photos (?thumb=1) and memories' photo or audio
GET /api/share/:token/people/:id/photo (anyone with the link) a portrait of the deceased
GET /api/calendar/:token.ics (anyone with the link) the anniversaries as iCalendar

Backups (admins)

Method & path Body Returns
GET /api/backups { snapshots, full }
GET /api/backups/:file · GET /api/backups/full.tar a daily snapshot (.db) · a fresh snapshot with every original file (.tar)

Layout

server/            Node + Express 5 + node:sqlite; one module per kind of data
  index.js         boot: database, timers (bin, e-mails, backups), the HTTP server
  app.js           the HTTP API: routes, who may do what, the write guard per tree
  db.js            SQLite, append-only migrations (PRAGMA user_version), transactions
  tree.js          trees and people: validation and family rules, export and import
  auth.js          sign-in codes, sessions per device, sign-in log, users and roles · passkeys.js (WebAuthn)
  privacy.js       what read-only users and share links see of the living
  activity.js      the change log and its undo · trash.js the recycle bin
  records.js       life events and documents with their pages · sources.js sources and citations
  memories.js      memories with recordings and photos · questions.js questions and answers · posts.js the family wall · feed.js Novice · for-you.js Zate · gatherings.js Srečanja
  todos.js         research to-dos · dna.js DNA matches · suggestions.js corrections from read-only users
  gallery.js       gallery items, images and face tags · images.js image and audio type checks · files.js the file store
  places.js        place lookups (Nominatim) and positions · shares.js share links · calendar.js the iCalendar feed
  gedcom.js        GEDCOM in and out · csv.js spreadsheets' CSV in and out · gedcom-merge.js matching a file's people with the tree's
  digest.js        monthly anniversaries e-mail · weekly.js weekly changes e-mail · mail.js SMTP or log
  backup.js        daily snapshots and the full backup · compress.js Brotli/gzip · messages-en.js English errors
public/            index.html · share.html · memorial.html · css/app.css · js/ (ES modules, no build step)
  js/app.js        boot, routing, rendering the open view, the details, people, the tree menu
  js/app/          context.js (shared state) · person-actions.js · tree-tools.js · account.js · importing.js · printing.js · sync.js
  js/text.js       the chosen language · lang/sl.js, lang/en.js (all wording) · lang/en-html.js (the pages' text) · i18n.js
  views            home.js (Domov) + wall.js and feed-items.js (Novice) · view.js (the chart, culled for big trees) · table.js · timeline-view.js · gallery.js (+ gallery-pairs.js, zip.js) · map.js
  details          panel.js · dialogs.js · memory-dialog.js · recorder.js · citation-dialog.js · dna-dialog.js · story.js (Zgodba)
  tree menu        anniversaries-dialog.js · stats-dialog.js · surnames.js + surnames-dialog.js · tour.js · sources-dialog.js · checks-dialog.js · todos-dialog.js
                   activity.js · news.js · trash.js · shares-dialog.js · gedcom-merge-dialog.js · merge.js · path.js · suggestions.js
  user menu        users.js · sessions-dialog.js · passkeys.js · backups.js · login.js
  pure (tested)    graph.js · kinship.js · layout.js · layout-full.js · paths.js · timeline.js · lifespans.js · anniversaries.js
                   namedays.js · on-this-day.js · checks.js · stats.js · moves.js · reports.js · research.js · dna.js
                   historic-places.js · photo-date.js
  printing         book.js (family book) · poster.js (whole-tree SVG) · reports.js
  small helpers    api.js · dom.js · avatar.js · toast.js · search.js · trees.js · photo.js · compare.js · share.js
                   comment-list.js · people-tags.js · hearts.js · gathering-card.js + gathering-dialog.js
test/              node --test: the API and its rules, migrations, privacy, and every pure module
e2e/               Playwright: the app in Chromium (app.spec.js) and axe-core accessibility (a11y.spec.js)