Ophis v9 shipped as a 91 MB Windows installer with a Chromium runtime and a sign-in gate. Under the wrapper: an un-obfuscated Electron app running a hand-rolled formula engine over Y — the axial-rotation count between two anchor dates. This guide reads it out: the fifteen shipped operations, the constants that drive them (π, φ, curvature, hepta), how to extend the grammar with your own 138 and 19 resonance operations, and a live cast you can drive from this page.
You give Ophis two dates — the source calls them X-Dates. Anything from Bitcoin halvings to your first passage into the Great Pyramid. Two is the minimum; more anchors mean more interval pairs to project from.
The engine counts the axial rotations between the pair — days, not years. For DAYS scope both dates are locked to midnight GMT and any time/location you set is discarded. That count is Y, the single variable every formula receives.
Each of the shipped operations transforms Y into a day-offset. The formula's X1+ or X2+ prefix decides which anchor the offset gets added to. The result is a projected Z-Date.
Each projection is scored — alpha operations weigh more than beta. Values close to the MSRF resonance lists (NORMAL / IMPORTANT / VORTEX) earn multipliers. Timeline chart on top, XLSX / PDF / CSV export below. This is the whole loop.
Ophis's power isn't the individual projection — any single Y·φ or Y·π estimate is easy to dismiss. The signal is convergence: when four different operations from different anchor pairs all land on the same date. That's what the convergence panel is looking for, and it's what your custom operations (§4) should be tuned to reveal.
The source uses these names without ceremony. They're borrowed from Gann-style cycle work with a coat of astronomical paint.
A named cycle. Contains anchors + operations + settings. Persists as one row in the .oph save file.
An input anchor. Date plus optional time and lat/long. Every cast needs at least two.
Days between two X-Dates — the axial rotation count. The one variable exposed to every formula.
An equation transforming Y into a day offset. Must begin X1+ or X2+.
A projected output date — Xanchor + f(Y). What the engine is actually predicting.
Operation weight class. Alpha ops score higher on match — considered "principled" projections.
Three resonance sets — 276 integers, 52 integers, 12 floats. A Z-value that lands near one gets a score multiplier.
Number of operations landing on the same Z-Date within tolerance. High hit-count days are the whole point.
Every formula below is a real Ophis default — extracted verbatim from ophis_model__params.js:65–110.
Tap any formula to copy it. Paste into the operations table inside the app. α · Alpha operations weight higher on match
than β · Beta. The Hepta-Cycle operation is disabled by default — added August 2025 per a source comment.
X2+oph_round(Y)
α · Alpha
X2+oph_flip(oph_round(Y))
α · Alpha
X2+Y/OPH_PHI
α · Alpha
X2+(Y/2.0)xOPH_PHI
β · Beta
OPERATION_EQUATION_FOR_ORIGINAL_BETA_PHI_6 in source.X2+YxOPH_PHI
α · Alpha
X1+(Y/2.0)xOPH_PI
β · Beta
X2+(Y/2.0)xOPH_PI
β · Beta
X1+YxOPH_PI
β · Beta
OPERATION_EQUATION_FOR_RADIUS_PROJECTION in source. Y × π, from earlier anchor.X2+YxOPH_PI
β · Beta
X2+Y/OPH_CRV
β · Beta
X1+(Y/2.0)xOPH_CRV
β · Beta
X2+(Y/2.0)xOPH_CRV
β · Beta
X1+YxOPH_CRV
β · Beta
X2+YxOPH_CRV
β · Beta
X1+YxOPH_HEP
off by default
Ophis ships with four constants — π, φ, κ, η — because those are the ones the original author saw. But the grammar is open: any custom operation you paste in gets validated and compiled the same way. Below are the operations that read the 138-Phoenix lattice and the 19-Metonic gear — the pair that makes the Chronicon come alive inside the Ophis engine.
The heaviest fingerprint of the lattice: Jan 19 2023 → Aug 2 2027 = 1,656 days = 138 × 12 = the Flood span (AM 1656). Pop those two dates into the live cast (§5) and Y comes out 1656 — the Genesis paragraph lock.
X2+oph_round(Y/138)*138
X2+Y+138
X2+Y+1656
X2+Y*138/100
X1+oph_round(Y/414)*414
X2+oph_round(Y/138)*138+138
X1+oph_round(Y/19)*19
X2+Y+19
X2+oph_round(Y/6940)*6940
X1+Y*19/10
X2+oph_flip(Y)+19
X2+oph_flip(oph_round(Y/138)*138)
X2+oph_round(Y/138)*19
X2+Y+792
X2+Y*360/365.2422
Three rules. It must start with X1+ or X2+. It may use only Y, numbers,
the constants, the oph_* functions, and arithmetic + − * / ( ). It must evaluate to a number.
Anything else is rejected by the strip → math.js pass before it ever compiles.
| Token | Meaning |
|---|---|
| X1 / X2 | The earlier / later anchor of the pair. Your equation begins with one of them, plus an offset. Ophis picks the anchor by inspecting the prefix — no run-time choice. |
| Y | The interval between the two anchors, in days. Signed positive for X1 → X2 order. |
| OPH_PI | Archaix π — 3.14 (two-decimal precision). |
| OPH_PHI | Golden ratio — 1.618 (three-decimal exception). |
| OPH_CRV | Curvature — 5.08 (π · φ, rounded). |
| OPH_HEP | Hepta-cycle — 7.01. |
| oph_round(n) | Nearest whole day. Used to snap projections cleanly. |
| oph_flip(n) | Reverse the digits, preserving decimal position. 1319 → 9131, 138 → 831. The palindrome maker. |
| oph_floor / oph_ceil | Round down / up to a whole day. |
| oph_abs / oph_sqrt | Absolute value / square root. |
| oph_sin / oph_cos / oph_tan | Trig functions. Argument in radians. Rarely useful in projections but grammar allows them. |
| oph_log / oph_exp | Natural log / exponential. |
| x | A bare x between terms is read as multiplication — YxOPH_PI is the same as Y*OPH_PI. The engine substitutes it during normalization. |
Every equation is normalized (constants substituted, x → *, whitespace stripped), then stripped
of its X1+ / X2+ prefix, then validated by math.js parse + evaluate with Y=10, then compiled with
native new Function("Y", "return " + body). The compiled function is cached on the operation. Runtime
passes only the axial rotation count.
A faithful port of the compute cycle: enter two anchor dates, the engine normalizes each of the 15 default
operations, compiles them with new Function("Y"), and applies the resulting delta to the X1 or X2 anchor.
Every Z-Date on the right is what the real app would produce with location disabled and DAYS scope. The 138/19 columns
light up when Y or |Δ| lands cleanly on a Phoenix or Metonic multiple.
| # | Equation | Anc. | Class | Δ days | Z-Date | 138 | 19 |
|---|
Note: DAYS scope discards HH:MM and lat/long (that's the shipping build's behaviour, gated by
FEATURE_FLAG__LOCK_DAY_SCOPE_TO_GMT = true). Sunset-aware rounding only kicks in for HH:MM scope in
the real app. The 138 and 19 columns are additions of this guide — not shown in the app itself, but visible here so
you can spot lattice hits at a glance.
oph_flip(1656) = 6561 = 812, which is 38.X2+Y+138 lands on 20 Dec 2027, X2+Y+1656 lands on 15 Feb 2032 (another 1656-hop).The isometric operation X2+oph_round(Y) produces 2032-02-15 — exactly one Flood span past the eclipse. That's 138 × 24 = 3,312 days from the Pyramid entry. The paragraph lock projects a paragraph lock forward.
The palindrome operation X2+oph_flip(oph_round(Y)) — the Holo-mirror — lands on 2045-08-24. 6561 days past 2027-08-02.
X2+YxOPH_PHI lands on 2022-05-13. X1+YxOPH_PI lands on 2024-03-11.The 2024-03-11 result — X1 + Y × π — is 51 days ahead of Bitcoin's actual all-time-high cluster in early May 2024. Under Ophis's tolerance windows, that lands inside a "convergence" if any other operation from the same anchor pair projects within ±30 days. It's the kind of thing the tool is built to hunt for. It's also easy to see how one such hit per anchor pair becomes a whole practice.
Interpretation is on you. The engine only counts.
Hover any module for its role. Colour-coded by layer.
require() Node modules. Combined with new Function() over user-editable equations, any expression surviving the strip → math.js filter runs in a Node-capable context.FEATURE_FLAG__REQUIRE_SIGN_IN = false with a comment literally reading "fake security camera." sha512.min.js is commented out. Flip the flag alone and init crashes.SKIN_MODE__MARKETS only swaps the header PNG and title. No market data feed. Source comment: "the beginning of an idea that never panned out really."type: Number cells only. Values, not formulas. Adding real =… formulas is a ~20-line change to ophis_view__export.js.FEATURE_FLAG__LOCK_DAY_SCOPE_TO_GMT = true, DAYS-scope events force lat/long to 0/0 and time to 00:00 GMT. Your Dallas coordinates are ignored unless you use HH:MM scope.APP_VERSION = "9" in config, but the header markup still says "v7". Runtime overwrites. package.json is authoritative.ophis_model__operations.js:54 and ophis_view__chart_datasets.js:1366 both ship debugger;. Harmless unless DevTools is open.ophis.html appends ?v=<rand> to every script and CSS tag on every launch. Startup is measurably slower than it needs to be.The source comments count from "2." through "15." (Ops #2 through #15), plus the newer Hepta-Cycle op with no number. So the actual literal DEFAULT_OPHIS_OPERATIONS array has 15 entries. An earlier "Op #1" was almost certainly removed before this ship, but the numbering was never renumbered — the comments are a paper trail.
The reverse-engineering report initially said 16 by counting the version-branched clone path; the deep-dive traced the array and confirmed 15.
Numerically, OPH_CRV = OPH_PI × OPH_PHI ≈ 5.08. The source calls it "curvature." Not a standard-named mathematical constant — the closest neighbours are the golden angle in radians (≈2.399) and the golden-φ-hyperbolic curvature used in certain phyllotaxis models, but neither of those is 5.08 exactly. Treat it as an author-invented composite constant.
Its effect on projections: it tightens the multiplier compared to bare π, and expands compared to bare φ. Ops using κ tend to produce medium-length projections that don't cleanly line up on 138 or 19 lattices — that's likely intentional; it makes them independent signals from the 138 grid.
It reverses the digits of a number while preserving decimal position. Ported verbatim:
flip(1319) = 9131. flip(138) = 831. flip(19) = 91. flip(1.5) = 5.1. flip(100) = 001 → parsed as 1.
Trailing zeros are lost because the reversed string is re-parsed as a number. That's a lossy operation on any Y ending in zero — worth knowing when your interval happens to be a round number.
Because it's the same interval as the Genesis Flood-count (Anno Mundi 1656 in the biblical chronology). The engine doesn't know that — Ophis has no theology. But when your input dates happen to be spaced 1656 days apart, every isometric-style operation produces multiples of that number, and the 138-lattice operations light up at every hop.
It's the numerological equivalent of finding your keys — the meaning is in the coincidence, not the machinery.
Yes, that's the primary way to use it. Open any Iso-Event → Operations settings → paste your equation into a new row. It's validated live as you type; if it passes the strip → math.js check it becomes a real compiled function on the next cast. That's how every operation in §4 above is meant to be added — Ophis's grammar is open by design.
The 138 and 19 lattice operations aren't in the shipping defaults, but every one of them satisfies the grammar rules in §5 and will be accepted verbatim.
The Export screen offers three formats. XLSX writes a three-column sheet (Date / Hits / Score) with computed numbers, no formulas. CSV is the same three columns via Papa Parse. PDF is landscape jsPDF with a chart snapshot, glossary page, and paginated Z-Date tables (15 rows per page).
The .oph save file is UTF-8 JSON — completely portable. You can hand-edit it, diff it, or generate one programmatically outside the app.
Two common reasons. First: your Y is enormous. If X1 and X2 are 3,000 years apart, X1+YxOPH_CRV projects 15,000 years past X1 — outside the Chart.js window. The engine also clamps at MAXIMUM_ROTATION_COUNT_Z = 36500 days (~100 years).
Second: your operations all use the same anchor. If every op begins with X2+, every Z-Date lives after X2. Mix X1+ and X2+ to get projections on both sides of the interval.
The sign-in gate suggests it once was, but the shipped v9 has that gate disabled with a comment reading "fake security camera." So the current build runs open. The developer's intent — commercial, evaluation copy, or free release — isn't stated in the source.
This guide is a reverse-engineering study of a legally obtained copy, focused on how the tool works. Nothing in it circumvents anything the shipping build hasn't already left open.
Tab moves between every control. ☾/☀ flips light/dark (follows your system on first visit). A− / A / A+ scales the whole page. Both remembered between sessions via localStorage. Reduced-motion is honoured. Nothing on this page phones home — the only external requests are the Google Fonts stylesheet on first load.