On this page AI compares GEDCOM with a rational data relationship structure
GEDCOM (especially the long-dominant 5.5/5.5.1 lineage-linked form) is a hierarchical, pointer-based text serialization designed in the 1980s for limited hardware and a narrow nuclear-family model. A rational data-relationship structure means a properly normalized relational (or graph) model with first-class entities, proper foreign keys or edge types, referential integrity, multi-valued attributes handled via junction tables, clear separation of evidence vs. conclusions, and flexible many-to-many relationships.
Here are the main structural and practical flaws of classic GEDCOM when measured against that ideal.
1. Hierarchical / denormalized design instead of true relational modeling
GEDCOM uses level numbers + tags + cross-reference pointers (@I123@, @F45@). Individuals (INDI) and families (FAM) form the core; almost everything else hangs off them. This sacrifices normalization (especially 3NF):
Location data is typically a free-text hierarchical string (city, county, state, country) with no independent Place entity that can change over time or be shared cleanly.
Events, attributes, notes, and sources are subordinated rather than first-class objects that multiple people can participate in.
The design was constrained by 1980s technology; modern RDBMS or graph stores have no such constraints, yet the model persists.
A rational model would have independent tables/entities for Person, Place (with historical names, coordinates, hierarchy), Event/Occurrence, Relationship (typed edges), Source, Citation, Evidence, etc., linked by proper keys.
2. Restricted relationship model (nuclear-family bias)
The only first-class linking construct is the FAM record (husband/wife + children). Other relationships (adoption, step, guardianship, same-sex unions, non-marital partnerships, complex blended families, non-parental associations) are second-class or require workarounds/notes/custom tags.
Parent-child and spouse links are bidirectional in theory but implemented via pointers that can become inconsistent.
No native support for many real-world relationship graphs; everything is forced into a tree-ish structure with limited cycle handling.
A rational structure treats relationships as typed, attributable edges (or a Relationship table with role, type, start/end, evidence) between Person entities. Graph models or junction tables handle this cleanly; GEDCOM does not.
3. Weak, ambiguous, or missing first-class concepts
Events vs. attributes are blurred and inconsistently implemented across software.
Sources and citations exist but are not structured for the Genealogical Proof Standard (evidence, analysis, conflicting evidence, personas vs. conclusions). GEDCOM-X later tried to fix this by elevating evidence and conclusions.
Places lack historical identity, coordinates as first-class data, or administrative-unit hierarchy that can be queried independently.
Dates support uncertainty (ABT, BEF, BET, etc.) but are still string-ish and hard to reason about rigorously in queries or validation.
Sex/gender was historically binary + U; intersex and modern gender concepts were late or incomplete.
Multimedia, DNA evidence, negative assertions, and complex notes are poorly integrated or extension-dependent.
In a rational model these become proper entities or well-typed attributes with constraints, versioning, and multi-participant support.
4. Pointer system and lack of integrity guarantees
Cross-references are local to the file and fragile. There is no enforced referential integrity, unique global identifiers (UUIDs), or transactional guarantees. Pointers can point to missing records, create inconsistencies between INDI and FAM, or produce loops that are hard to detect/validate. Merging two GEDCOM files is notoriously lossy and error-prone.
A rational database uses primary/foreign keys (or graph edges) with constraints, cascading rules, and proper identity (UUIDs or stable external IDs).
5. Extensibility via custom tags creates dialects and data loss
Vendors add _TAG extensions. These are ignored or mangled by other software, so “round-tripping” (export → import) routinely loses data. Incomplete implementations of the core standard compound the problem. The result is a set of near-compatible dialects rather than a reliable interchange format.
A rational model either defines a rich enough core schema or uses a clean, versioned extension mechanism (e.g., JSON Schema, RDF, or explicit extension points) that does not silently discard data.
6. Text-file serialization problems
Flat hierarchical text is inefficient for large trees, hard to update incrementally without rewriting the whole file, and lacks proper indexing/transactions.
Character encoding history (ANSEL → UTF-8) caused real-world corruption for non-Western names.
No built-in versioning, audit trail, or collaborative concurrency model.
A proper database (relational or graph) handles concurrent edits, partial updates, indexing, and querying far better; GEDCOM is an interchange format that many programs unfortunately treated as a database.
7. Cultural and modeling assumptions
The model assumes Western nuclear families, surnames that fit certain patterns, and places that map cleanly to modern administrative units. Non-European naming systems, complex kinship, and historical place-name changes are awkward.
Comparison snapshot
Aspect |
Classic GEDCOM |
Rational relational/graph model |
|---|---|---|
Core structure |
Hierarchical pointers + FAM/INDI |
Normalized entities + typed relationships |
Relationships |
Nuclear-family biased |
Arbitrary typed many-to-many |
Places / Events |
Subordinated strings / tags |
First-class, shareable, historical |
Sources / Evidence |
Basic citations |
Full evidence–conclusion separation possible |
Integrity |
Pointers, no hard constraints |
Keys, constraints, referential integrity |
Extensibility |
Custom _ tags → dialects |
Schema/versioned extensions |
Query / update |
Sequential text parse |
Indexed, transactional, set-oriented or graph |
Interchange reliability |
High data loss in practice |
Can be lossless if schema is rich enough |
Modern context
GEDCOM 7 improved some syntax, encoding, negative assertions, and documentation of extensions, and GEDCOM-X (a parallel FamilySearch effort) moved toward a richer conclusion + evidence model with JSON/XML and no mandatory FAM record. Neither fully replaces a clean internal relational or graph design; most serious software still maps a richer internal model to GEDCOM for interchange and accepts some loss.
Bottom line: GEDCOM succeeded as a pragmatic 1980s interchange format and remains useful for basic data movement. As a data relationship structure it is outdated—denormalized, relationship-poor, integrity-weak, and culturally narrow. A rational design treats people, relationships, events, places, and evidence as first-class, properly linked entities with constraints and clear semantics. That is why many modern genealogy systems keep a superior internal model and treat GEDCOM as an imperfect export/import bridge.
Comparing GEDCOM to XYFT
XY Family Tree (XYFT / xyfamilytree.com) is a free Windows genealogy program whose creator explicitly positions it as a more rational alternative to GEDCOM. It uses a simple normalized relational structure stored as linked XML files, rather than GEDCOM’s hierarchical pointer-based text format.
Core data models
GEDCOM (classic lineage-linked)
Hierarchical text with level numbers and tags.
Core records: INDI (individual) and FAM (family/nuclear unit).
Relationships expressed mainly via the FAM record (HUSB/WIFE + CHIL pointers).
Events, attributes, sources, notes, and places are subordinated to individuals or families.
Designed in the 1980s around a nuclear-family model; many real-world situations require workarounds or custom tags.
XYFT
Five simple normalized tables (stored as XML):
People – primary person data + father/mother IDs + UUID + notes + custom fields.
Marriages – links two people (with flexible gender handling).
Associations – general person-to-person links (non-marital relationships).
Sources – media, documents, web links, etc.
Link People to Sources – many-to-many junction with comments.
Parentage is recorded directly on the person (IDofFather / IDofMother).
Custom fields are first-class and searchable.
Explicitly claims compliance with database normalization rules.
Key comparison points
Aspect |
GEDCOM |
XYFT |
Winner / Notes |
|---|---|---|---|
Structure |
Hierarchical, denormalized, pointer-based |
Normalized relational (5 tables) |
XYFT closer to good DB design |
Parent-child links |
Via FAM record |
Direct on Person (FatherID / MotherID) |
XYFT simpler & more direct |
Spouses / partners |
FAM-centric (nuclear bias) |
Separate Marriages table; supports MM/FF/UU |
XYFT more flexible |
Other relationships |
Limited / custom tags / notes |
Dedicated Associations table |
XYFT cleaner |
Sources & media |
Citations possible but often lossy on export |
First-class Sources + many-to-many links + full media in folder |
XYFT stronger for media |
Custom data |
Proprietary _ tags → dialects & data loss |
Open custom XML fields, searchable |
XYFT more future-proof for user needs |
Interoperability |
De-facto industry standard (almost every program) |
Proprietary XML + XYXchange (zip of whole folder); GEDCOM import/export exists but imperfect |
GEDCOM wins heavily |
Data completeness on transfer |
Frequent loss (dialects, incomplete support) |
XYXchange keeps everything (data + media); GEDCOM round-trips still lose some data |
XYXchange better internally; GEDCOM better externally |
Identity |
Local @I123@ pointers |
Local numeric ID + UUID for cross-family uniqueness |
XYFT better for multi-tree work |
Same-sex / non-traditional |
Improved in later versions, still awkward |
Explicitly supported without forcing nuclear model |
XYFT more natural |
Adoption / complex parentage |
Possible via tags / notes |
Handled via parent links + associations + notes |
Both workable; XYFT more explicit |
Places & dates |
Free-text hierarchical places; flexible date grammar |
Free-text places; flexible date text + year extraction |
Roughly equal (neither is highly structured) |
Platform & ecosystem |
Universal |
Windows desktop only; small user base |
GEDCOM |
Philosophical differences
GEDCOM prioritizes interchange between many programs, even if the model is imperfect and data is often lost or distorted.
XYFT prioritizes a clean internal model that matches biological parentage more directly, treats marriages and associations as separate relationships, and keeps media/sources tightly linked. The creator argues that most of GEDCOM’s event/attribute tags are culturally specific and unnecessary for many researchers, and that a simple normalized core + custom fields is more honest and maintainable.
Practical trade-offs
Use GEDCOM when you need to move data between different software, collaborate widely, or publish to major sites (Ancestry, FamilySearch, MyHeritage, etc.). It remains the only widely supported interchange format.
Use XYFT if you want a lightweight, free program with a cleaner relational structure, strong media handling, easy multi-family management, UUIDs, and full-folder backups via XYXchange. It is particularly attractive if you find GEDCOM’s nuclear-family orientation and custom-tag chaos frustrating.
Round-tripping through GEDCOM will still lose some of XYFT’s richer structure and media links, just as it does with most other programs.
Summary: XYFT is a deliberate attempt at a more rational, normalized data relationship structure than classic GEDCOM. It succeeds on internal cleanliness, flexibility for non-traditional families, and media integration. GEDCOM wins decisively on ecosystem size and interchange reliability. Many serious users keep a richer internal model (whether XYFT’s or something like Gramps/RootsMagic) and treat GEDCOM as an imperfect export/import bridge.
As a rider to the above page written by AI in 2026 let me give you some history. The original model was developed in 2005 when Microsoft released Visual Studio Express with a free version of Visual Basic. By then I had a lot experience with relational databases and it was easy to plan a structure and create a program for a PC. At first I had never heard of GEDCOM - I was just working to help my sister who had a lot of pretty Excel sheets. My interest then turned to PHP.
But that was 20 years ago. A new hopeful, pompous standard, fhiso, came forth and disappeared and now the imperfect GEDCOM dominates. I'm now 79 years old and have little interest in competing with GEDCOM, but it would be nice to think that when I look down from my heavenly perch, XYFT has won the day. It just needs new blood to take it forward.
Meantime, I have other projects to play with. Me and Claude and our mates that is 😉.
XY Family Tree © 2026
Berkshire, England