HORCOM: Resurrecting Robert Rettig’s Classic Astrology & Ephemeris Engine in Modern C++20 and Qt 6

Few challenges in modern software engineering demand as much patience, mathematical rigour, and historical detective work as revitalising complex scientific or calculation software from the personal computer boom of the late 1980s. Across astronomy, radio communication, and computational mechanics, dozens of brilliant domain-specific programs were originally authored in procedural languages like BASIC, Turbo Pascal, or Forth on architectures such as the Atari ST, Commodore Amiga, and early MS-DOS. When original creators retire or pass away, these decades-long masterpieces often vanish into digital obsolescence, trapping proprietary data formats and custom algorithms in crumbling archives.

HORCOM stands as a breathtaking exception to this tragic cycle of software abandonment. Conceived, designed, and continuously refined between 1989 and 2010 by German programmer and astrologer Robert Rettig, HORCOM served as a premier European professional calculation suite. Rather than relying entirely on generic commercial ephemerides, Rettig engineered his own celestial engines, numerically integrating gravitational perturbations across centuries for bodies like Chiron, Quaoar, Eris, and Halley’s Comet. Following his death, his close friend André safeguarded his complete archive, enabling open-source developer Dominik Schwimmbeck to undertake an exhaustive, procedure-by-procedure port of more than 50,000 lines of legacy GFA-BASIC into clean, deterministic C++20 and modern Qt 6.

Today, HORCOM lives on as a free, open-source cross-platform suite licensed under the GNU General Public License v3.0 (GPL-3.0-or-later). Whether your interest lies in celestial mechanics, observational astronomy, the mathematical nuances of the Munich rhythm theory, or the art of software archaeology, the revival of HORCOM offers a masterclass in how to preserve computing heritage without compromising modern software standards.


TL;DR: HORCOM is a free, open-source astrology suite ported to C++20 and Qt 6 with topocentric parallax, custom N-body ephemerides, and standalone Linux AppImages. Originally built by Robert Rettig in GFA-BASIC between 1989 and 2010, the project has been meticulously modernised by Dominik Schwimmbeck to deliver deterministic calculations, seven house systems, planetary returns, and headless SVG generation across Linux and Windows.

Last updated: November 2026.


What is HORCOM?

HORCOM is a free and open-source desktop astrology and celestial calculation application written in C++20 and Qt 6 that computes high-precision birth charts, transits, planetary returns, and complex astrological progressions across multiple house and coordinate systems.

Unlike contemporary web calculators that operate as thin front-ends to remote APIs, HORCOM is a self-contained, offline desktop powerhouse. It casts and renders high-resolution chart wheels, computes dynamic transits and linear time graphs, tracks primary and symbolic directions, conducts synastry comparisons, and manages large chart collections. It is equally capable of running as an interactive GUI application with dark and light themes or as a headless command-line utility capable of piping SVG vector wheels directly into automated publishing pipelines.

+-----------------------------------------------------------------------------+
|                            HORCOM Desktop Architecture                      |
+-----------------------------------------------------------------------------+
| [ GUI Shell (Qt 6) ]             | [ Command-Line Tool (horcom CLI) ]       |
| - QPainter Display List Engine   | - Headless Parameter Parsing             |
| - High-DPI Canvas & Themes       | - Automated SVG / Report Generator       |
+----------------------------------+------------------------------------------+
                                  |
                                  v
+-----------------------------------------------------------------------------+
| [ Chart Synthesis & Render Core (src/chart, src/render) ]                   |
| - 7 House Systems (Placidus, Koch, Topocentric, Regiomontanus, etc.)        |
| - Munich Rhythm Theory (7-Year Phases, Septars, Trigger Tables)             |
| - Predictive Modules (Transits, Solar/Lunar Returns, Kühr Primary Direct.)  |
| - Aspect Scanning, Orbs, Midpoints, Harmonics, and Arabic Parts             |
+-----------------------------------------------------------------------------+
                                  |
                                  v
+-----------------------------------------------------------------------------+
| [ Astronomical & Ephemeris Engine (src/ephem, src/time, src/core) ]        |
| - VSOP87 Analytical Series (Sun, Earth, Mercury through Neptune)            |
| - Truncated Meeus ELP-2000 Lunar Theory (60 Longitude / 60 Latitude Terms)  |
| - Störmer-Cowell 12th-Order N-Body Numerical Integrator (.EPH Archives)     |
| - Topocentric Parallax Correction (Real Observer Latitude, Longitude, Alt)  |
| - Delta T, Sidereal Time, Julian/Gregorian Calendars, Pre-1900 LMT Database |
+-----------------------------------------------------------------------------+

The Legacy of Robert Rettig

Robert Rettig was a dedicated German astrologer and computational researcher who began crafting HORCOM during the golden era of the 16-bit Atari ST. In the late 1980s, computing planetary coordinates required deep familiarity with celestial mechanics, matrix trigonometry, and hardware optimisation. Over two decades, Rettig expanded HORCOM through successive iterations of GFA-BASIC, eventually migrating the codebase to 32-bit Microsoft Windows where it was distributed on CD-ROM and through his personal website until around 2010.

Rettig was notable for his refusal to take algorithmic shortcuts. In an era when most astrological programs omitted minor planets and centaurs due to the computational expense of orbit propagation, Rettig developed his own orbital integration pipelines. When astronomical ephemerides for newly discovered trans-Neptunian objects like Quaoar and Eris (originally designated Xena) were nonexistent or restricted to professional academic mainframes, Rettig derived initial orbital vectors and numerically integrated their positions forward and backward across multiple centuries.

The Modern Port: Software Preservation Done Right

Following Robert Rettig’s passing, his close friend André made his complete archive available so his life’s work wouldn’t be lost to time. Open-source engineer Dominik Schwimmbeck accepted the mantle, setting an uncompromising standard for software preservation:

  1. Deterministic Equivalence: The original software defines mathematical truth. Every ported routine was initially mapped to reproduce identical results against Robert Rettig’s legacy outputs down to the smallest floating-point fraction.
  2. Transparent Procedure Accounting: In docs/coverage.md, Schwimmbeck catalogued every single one of the 1,093 procedures in the original 50,397-line GFA-BASIC listing. The ledger accounts for 703 routines ported directly by name, 63 absorbed into cohesive modern C++ structures, and 327 obsolete Atari GEM/Windows GDI screen and mouse routines superseded by Qt 6.
  3. Preservation of Comments: Robert Rettig’s original German commentary and mathematical annotations were retained directly inside the C++20 source files, ensuring his voice, insights, and technical rationale remain permanently entwined with the code.
  4. Verifiable Testing: The codebase incorporates extensive regression test suites checking calculations against Jean Meeus’s standard astronomical test cases, original binary .DAT and .EPH files, and independent cross-verifications.

Astronomical Engines and Ephemeris Production Under the Hood

To appreciate HORCOM, one must understand that it is fundamentally a high-performance celestial ephemeris engine wrapped in a specialised astrological interface. The computational core handles time scales, orbital mechanics, coordinate rotations, and optical corrections with immense precision.

The Three-Tier Planetary Engine

HORCOM divides the celestial sphere into three distinct computational tiers based on orbital stability, body mass, and theoretical availability:

Celestial Tier Bodies Included Computational Method Data Source
Primary Major Planets Sun (Earth reversed), Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune Truncated VSOP87 periodic series evaluated with analytical time derivatives Binary term tables (PLANETS.DAT and PLANETS.NDX)
Lunar Theory Earth’s Moon, Lunar Nodes, Mean/True Apogee (Black Moon / Lilith) Meeus Chapter 45 (truncated ELP-2000 series with 60 longitude/radius terms and 60 latitude terms) Hardcoded harmonic coefficients (src/ephem/)
Integrated Minor Bodies Pluto, Chiron, Pholus, Nessus, Damocles, Ceres, Pallas, Juno, Vesta, Quaoar, Eris, Halley’s Comet High-order numerical N-body gravitational integration in 40-day ephemeris steps Pre-calculated binary .EPH archives with polynomial interpolation

The Ephemeris Production Pipeline: Runge-Kutta and Störmer-Cowell Integration

The way Robert Rettig built the binary .EPH files for minor bodies is an extraordinary feat of procedural programming. His generation pipeline (src/tools in legacy listings like QUAOAR.LST and CHIROGEN.LST) executed in rigorous mathematical stages:

  1. Osculating Elements to State Vectors: The pipeline ingested osculating orbital elements at a known epoch, solved Kepler’s equation to an accuracy of 1e-12 using bisection, and derived starting heliocentric Cartesian positions and velocities.
  2. Runge-Kutta 6th-Order Starter (RK6): Because high-order multistep integration formulas require prior historical points before they can self-propagate, Rettig implemented a 7-stage, 6th-order explicit Runge-Kutta method (based on Guthmann’s formulations). Variable internal sub-steps were assigned based on orbital velocity: 0.0005 days for Mercury, 0.005 days for Earth/Mars, and 0.02 to 0.05 days for outer planets. This produced exactly 13 starter points spaced at 0.5-day intervals.
  3. 12th-Order Störmer-Cowell Multistep Integration: With 13 reference steps established, the generator switched to a classical summed-second-difference Störmer/Stiefel integrator running to the 12th central difference, adopting the methods documented in the US Naval Observatory’s 1951 Astronomical Papers Vol. XII (“Coordinates of the Outer Planets 1653-2060”).
  4. N-Body Perturbation Model: The equations of motion calculated full heliocentric gravitational perturbations from the Sun, the major planets, and the asteroid belt, accounting for indirect barycentric acceleration terms.
  5. Bidirectional Sweep: The integrator marched forward to the target future epoch (e.g., year 2101), reversed the 13-point stencil, flipped the sign of the step width, and swept backward to year 1499, writing out random-access records in descending Julian Date order at regular 40-day intervals.

In modern C++20, HORCOM loads these binary .EPH archives directly through memory-safe file decoders and executes polynomial interpolation (ipol/ipol3) to calculate instant positions with negligible latency.

Topocentric Parallax Correction

Standard astrological software typically calculates geocentric coordinates: positions projected as if observed from an imaginary vantage point at the exact geometric centre of the Earth. While acceptable for distant outer planets where planetary distance dwarfs the Earth’s radius, this assumption introduces noticeable angular errors for the Moon and near-Earth objects.

                    Topocentric Parallax Geometry

                           [ Celestial Body ]
                              /          \
                             /            \
           Topocentric Line /              \ Geocentric Line
             of Sight      /                \ of Sight
                          /                  \
                         v                    \
               [ Observer on Surface ]         \
                     |   (r, phi', theta)       \
                     |                           \
                     |  Earth Radius             v
                     +-------------------> [ Earth Center ]

HORCOM features a dedicated topocentric calculation mode (ko_tr1, ko_tr2, and par). By factoring in the observer’s true geographic latitude, longitude, and elevation above sea level, HORCOM calculates topocentric parallax vectors. The Moon’s apparent position on the ecliptic can shift by up to an entire degree depending on whether geocentric or topocentric geometry is selected, an astronomical variance that can alter house placement and aspect timings.


Core Capabilities: From Natal Wheels to the Munich Rhythm Theory

HORCOM provides a broad suite of astrological techniques, bridging classical Western methods, 20th-century European traditions, and modern statistical research:

1. Seven House Systems

The software implements seven classical and modern house division algorithms:
– Placidus: The standard semi-arc time-proportional system.
– Topocentric (Polich/Page): An empirical system closely approximating Placidus through polar rotation geometry.
– Koch: The G. Koch birthplace house system based on equatorial division.
– Regiomontanus: Space-based division along the celestial equator.
– Campanus: Prime-vertical geometric division.
– Equal: 30-degree uniform segments projected directly from the Ascendant.
– Vehlow Equal: Equal houses with the Ascendant centred at 15 degrees of the 1st house.

2. The Munich Rhythm Theory (Münchner Rhythmenlehre)

One of HORCOM’s most distinguished features is its native support for the Munich rhythm theory, formulated by the German astrologer Wolfgang Döbereiner. The system interprets personal life arcs through structured 7-year cyclic rhythms across the natal houses. HORCOM computes:
– Phase Walks: Visual progression paths stepping through the houses at set rates (e.g., 7 years per house).
– Septars (Septare): Specific cyclic return charts computed at 7-year milestones throughout life.
– Trigger Tables (Auslösungstabelle): Precise date tables identifying when natal points, house cusps, and critical degrees are triggered.
– Degree-Date Lists (Grad-Datum-Liste): Tabular projections linking ecliptic degree activations with historical and future dates.

3. Dynamic Predictive Tools

  • Transits: Visualised as dual-wheel comparison rings, high-density coordinate tables, or linear transit graphs over multi-month windows.
  • Solar, Lunar, and Planetary Returns: High-speed root-finding algorithms locate the precise astronomical moment a celestial body returns to its exact natal ecliptic longitude, generating return charts individually or in automated series of up to 84 returns.
  • Primary Directions: Implementation of primary directions following the mathematical frameworks of E. C. Kühr, alongside secondary progressions, solar arc directions, and Krafft-Goerner dynamograms.

4. Synastry and Relationship Analysis

HORCOM supports deep relational analysis between two independent charts:
– Dual Wheel Display: Inner and outer concentric wheels with cross-aspect links.
– 90-Degree Dial: Hamburg School midpoint dial for rapid visual scanning of hard aspects (conjunction, square, opposition).
– Composite and Combine Charts: Midpoint charts and geographical midpoint syntheses.

5. Statistical Database Research

HORCOM includes a statistical analysis module capable of scanning entire archives of birth data (stored in Rettig’s .DAT format or standard Astrological Association Format .AAF). Users can run queries across thousands of charts to discover patterns based on sign occupancy, house placement, aspect combinations, or midpoints.


Architectural Comparison: HORCOM vs Other Astrology Suites

To understand where HORCOM fits in the modern world of celestial and astrological software, let us evaluate it alongside leading open-source and commercial alternatives:

Feature / Metric HORCOM Astrolog Morinus Solar Fire
Primary Authors Robert Rettig / Dominik Schwimmbeck Walter D. Pullen Robert Nagy Astrolabe / Alabe
Licence Free & Open Source (GPL-3.0+) Open Source (GPL-compatible custom) Free & Open Source (GPL-3.0) Proprietary Commercial
Core Language Modern C++20 C (ANSI / C99) Python (wxPython) C++ / Visual Basic (Win32)
GUI Framework Qt 6 (Widgets / High-DPI QPainter) Custom Windows GDI / X11 / CLI wxWidgets (wxPython) Native Windows API
Calculation Engine Custom VSOP87 + Meeus + Störmer N-Body Integrator Swiss Ephemeris / Placalc / Matrix Swiss Ephemeris (pyswisseph) Swiss Ephemeris
Topocentric Parallax Fully supported (observer surface geometry) Supported Basic support Fully supported
Munich Rhythm Theory Full native implementation (Septars, Triggers) Not supported Not supported Partial / Plugin
Ephemeris Extent Self-contained binary .EPH (years 1499-2101) External Swiss Ephemeris files required External Swiss Ephemeris files required Bundled proprietary / Swiss Ephemeris
Headless CLI Mode Yes (horcom CLI with SVG output) Yes (Extensive CLI switches) Minimal No
Platforms Linux (AppImage), Windows x64 Windows, Linux, macOS Windows, Linux, macOS Windows only

Hands-On Walkthrough: Installation and Workflow

HORCOM has been designed for frictionless deployment. Because it doesn’t rely on complex runtime dependencies or web servers, you can run it anywhere in seconds.

Installing and Running on Linux

On Linux, HORCOM is distributed as a standalone, zero-installation AppImage that runs on modern 64-bit distributions (Ubuntu 22.04+, Debian 12, Fedora, Arch, and openSUSE):

# 1. Download the latest release AppImage
wget https://github.com/horcom-rr/HORCOM/releases/latest/download/horcom-linux-x86_64.AppImage

# 2. Grant execution permissions
chmod +x horcom-linux-x86_64.AppImage

# 3. Launch the application
./horcom-linux-x86_64.AppImage

Tip: If your distribution lacks AppImage FUSE support (such as modern Ubuntu 24.04 setups without older compatibility libraries), simply install the lightweight FUSE interface package:
– Ubuntu/Debian: sudo apt install libfuse2t64 (or libfuse2)
– Fedora: sudo dnf install fuse-libs

All user configuration, custom chart collections, and preferences are automatically stored in standard XDG paths (~/.config/horcom and ~/.local/share/horcom/data), meaning you can smoothly update to newer AppImage releases without losing any personal records.

Installing on Windows

On Windows 10 and Windows 11:
1. Download horcom-windows-x64.zip from the official GitHub releases page.
2. Extract the archive into a convenient directory (for example, C:\Tools\HORCOM or Documents\HORCOM).
3. Run horcom_gui.exe.

Because the Windows build runs in portable mode, your chart database and settings reside inside the adjacent data folder. You can keep HORCOM entirely on an external USB flash drive or inside an encrypted volume.

Headless Chart Rendering via the CLI

In addition to the Qt 6 GUI, HORCOM compiles a standalone command-line executable named horcom. This allows developers, researchers, and system administrators to automate chart generation without launching a graphical session:

# Calculate a chart and export a pure SVG vector graphic wheel
horcom --date 13.10.1992 --time 03:00 --lon 11.32 --lat 48.17 --extras --svg /tmp/natal_wheel.svg

The resulting vector graphic is crisp, infinitely scalable, and immediately ready for embedding into HTML documents, academic publications, or automated reporting systems.


Why Software Archaeology Matters: Fixing Bugs While Preserving History

One of the most inspiring facets of the HORCOM project is how the development team handled the boundary between historical preservation and mathematical bug fixing. In pure software preservation, purists sometimes argue that historical bugs must be preserved indefinitely to maintain backwards compatibility. In calculation and scientific software, bugs represent implementation mistakes that corrupt the user’s intended reality.

Dominik Schwimmbeck adopted a disciplined, documented strategy. Every intentional correction was accompanied by a dedicated automated test confirming both the flaw in the original and the mathematical correctness of the fix:

  • Sign Line Boundary Folding in Linear Graphics: In the original GFA-BASIC routine a18_lin, sign division lines evaluated using an index multiplied by the first folded boundary. Under base angles below 360 degrees, only multiples of a single position were attempted; under 45 degrees, only the 240-degree boundary appeared. The C++20 port independently folds every sign boundary, correctly rendering both the 120-degree and 240-degree division lines (test_render.cpp).
  • Calendar Step Leaps in Direction Windows: The legacy routine a18asw1 subtracted 31 days (jdbeg - 31) to establish the previous interval for a one-month window. Stepping backward from 1 March opened the window on 1 January, skipping February entirely. The port anchors interval steps strictly to the first day of the calendar month designated by the step (test_directions.cpp).
  • Septar House Unit Offsets in Rhythm Theory: The legacy routine a174init computed Septar offsets as sn = (sen - 1) * vp regardless of whether months or years were selected. Because a Septar traverses twelve houses, the calculation dated its progression from the second year of life rather than the twenty-fourth. The modern C++ port normalises the unit factor correctly (test_symbolic.cpp).
  • Negative Age Fraction Splitting: The legacy table routine a175 extracted years using INT(sn + lj) and months strictly from FRAC(lj). For negative offsets (such as prior life events or pre-natal returns), an age of minus 2.25 years was erroneously printed as -3 -3.0. The C++ rewrite correctly partitions sign and magnitude across both components (test_symbolic.cpp).

Every deviation from Robert Rettig’s original binary behavior is catalogued in public documentation (docs/architecture.md), providing future researchers with complete transparency.


Summary: A Masterclass in Open-Source Software Preservation

HORCOM is far more than an astrology program; it is a living monument to the ingenuity of early desktop software developers and the dedication of the open-source preservation community. Robert Rettig spent more than two decades crafting an independent, mathematically rigorous cosmos inside 50,000 lines of procedural code.

By refusing to let that knowledge dissolve into history, Dominik Schwimmbeck and André have delivered a masterwork. The C++20 and Qt 6 rewrite demonstrates how legacy software can be honoured, verified, corrected, and brought into the modern era with clean architecture, byte-level precision, and zero corporate bloat.

For anyone who appreciates celestial mechanics, elegant desktop engineering, or the preservation of computer science history, HORCOM is an open-source project well worth exploring, studying, and running on your own machine.


Sources and Further Reading


73 de 9M2PJU.

Post Comment