DeadEnds Swift

[Thomas Wetmore]

Ancient Liners,

I have alluded to DeadEnds as a follow-on project for LifeLines (for =
decades!!). It now exists in two forms, neither polished nor complete. =
There is a C version and a Swift version. Forget the C version because =
it doesn't have a user interface. The C version was a proof of concept =
to completely replace the database system with an in-Ram system, and =
that I could write high quality collection types in C. This has proven =
to be an excellent approach. Large databases are read, validated, =
indexed and ready to go in milliseconds. All DeadEnds databases (C and =
Swift) are now "just" Gedcom files. It turns out that my collection =
types are nearly identical to those provided by Go, a language I also =
considered as a replacement for C.

Though not polished these two projects are far enough along that any =
interested developer could make easy use of them.

Frustration with lack of good memory management and good collection =
types in C drove me to port it all to Swift a couple years ago. Plus =
with ChatGpt acting as tutor and guide to SwiftUI (which is really too =
much for my aged brain to fully grasp), I have moved along at high speed =
into features that I never would have tackled on my own. For example, =
the "Desktop" feature, using an index card metaphor, has been lots of =
fun to implement.

The purpose of this note is to let you know that the code for the two =
projects are available on GitHub in two repositories at:

https://github.com/TomWetmore/DeadEndsSwift
https://github.com/TomWetmore/DeadEnds.

This may not generate any interest, but if it does, I will happily =
correspond about what is in these repositories.

The rest of this is the markdown readme in the DeadEndsSwift repository.
=
--------------------------------------------------------------------------=
--------------




# DeadEndsSwift

DeadEndsSwift is a macOS genealogy software system written in Swift. It =
consists of a core genealogical library, a SwiftUI-based application, =
and some command line programs that use the library.

DeadEnds is the successor to my C-based DeadEnds project, which was the =
successor to my C-based LifeLines program written in the 1990's. =
DeadEnds Swift supports reading Gedcom files, building an in-memory =
genealogical database, and visualizing family relationships.

In the rest of this file DeadEnds always means DeadEnds Swift, unless =
DeadEnds C is used directly.

## Features

- Reads Gedcom files into internal (in-RAM) databases. DeadEnds can read =
Gedcom files from any standard that uses the normal lineage-linking tags =
(FAMS, FAMC, HUSB, WIFE, CHIL), and a few other standard tags (NAME, =
SEX, BIRT, DEAT, MARR, DATE, PLAC, SOUR, ...). DeadEnds uses Gedcom =
files as backing store for its databases when the program is not =
running. DeadEnds does not think of Gedcom files as anything other than =
snoozing DeadEnds databases.
- Displays Person, Family, Pedigree, and other views. The SwiftUI app =
features a number of views and screens. These are under active =
development.
- One exciting screen is the Desktop view, in which persons show up in =
the form of index cards that can be moved and manipulated on the =
Desktop. I hope to continue developing this metaphor, as it represents =
ideas formulated more than 40 years ago when I had not the time to work =
on them.
- Supports editing of genealogical data -- adding, deleting and =
modifying records, adding, removing and changing family relationships.
- Supports searching. LifeLines supports search by name only, as each =
index in LifeLines requires custom records in the database and custom =
data structures at run time. With DeadEnds there is no persistent =
database, and there is a rich set of container structures, so writing =
date and place indexes is easy, so DeadEnds search can use names, dates, =
and/or places.
- Supports an internal scripting language. The scripting language is =
nearly identical to that of the LifeLines scripting language. Current =
access to this feature is a little awkward becuase I have not had the =
time to fashion a Swift parser for the scripting language (the C version =
used yacc). There is a patch for this however. I have written a =
yacc-based (same yacc file used by LifeLines) C program that parses =
LifeLines scripts and converts them to S-expressions (Lisp). DeadEnds =
Swift has a command line program that reads the S-expressions, converts =
them to an abstract syntax tree matching that of LifeLines, and then =
interprets the scripts. This is a proof of concept only, though it =
works.

## Targets

The DeadEnds project consists of targets. Here is an introduction to =
the main ones.

- DeadEndsLib -- the base genealogical library. It contains the database =
and its import stack; the Gedcom node, record, person, family datatypes; =
the interpreter; and other code.

- DeadEndsApp -- the SwiftUI application; it has several standard =
genealogical screens (called pages in Deadends), includling person, =
family, pedigree, editing, merging, and desktop (see above).

- RunScript -- the Swift half of the script interpretation process. It =
reads a LifeLines script from an S-expression file, then loads a =
database using the regular database import stack, and then interprets =
the script

- DeadEndsIPad -- place holder for an upcoming iPad version of the =
DeadEnds app.

=20

## Status

Currently under active development. All versions found at GitHub should =
compile completely and work.

## License

(TBD) I haven't decided, but the code is avalable on git hub at =
https://github.com/TomWetmore/DeadEndsSwift=

[Stephen Woodbridge]

Very cool, thank you, Thomas!
I have also found the ChatGPT has assisted my aging brain and made coding possible for tasks I might not have tackled otherwise.

I’ve traveling in our RV while I can still do that, but hope to get back to doing genealogy again when I can.

-Steve

Sent from my iPhone

> On Feb 25, 2026, at 10:13 AM, Thomas Wetmore <ttwet...@gmail.com> wrote:
>
> Ancient Liners,

> --
>
> ---
> You received this message because you are subscribed to the Google Groups "rootsdev" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to rootsdev+u...@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/rootsdev/D7AB85EB-3FA5-48E8-A850-7F5FEB1FA2F0%40gmail.com.