Start with GAL-2 Time Contract Get API Key + Quickstart Plans Technical pilots · macOS + Linux · API-backed gal2_time

Governed Time Path

Applications consume gal2_time through a Time Contract instead of trusting raw time directly.

Temporal Circuit Breaker

When time becomes stale, degraded, unavailable, or unsafe, GAL-2 holds, rejoins, or fails closed before bad time becomes state.

Works With Your Timing Stack

Complements GNSS, PTP, NTP, chrony, grandmasters, cloud systems, and existing infrastructure at the application boundary.

Application-facing Time Contract

How GAL-2 works

GAL-2 becomes the governed time path your application calls before time becomes committed state.

01

Run the local daemon

Deploy the GAL-2 Time Contract daemon beside your application, using your existing timing stack as the upstream reference path.

02

Request governed time

Your application calls the local /contract endpoint and receives gal2_time plus runtime contract metadata.

03

Commit only through the contract

Use gal2_time for protected state-changing operations. If safe_to_consume is false, block or defer those operations instead of silently falling back to raw time.

curl -s http://127.0.0.1:9095/contract

The Time Contract answers the question that raw clocks do not.

Not only “what time is it?” but whether that governed time can safely become application state right now.

gal2_time safe_to_consume valid_until mode reason monotonic_sequence source_lineage

Your timing stack delivers time. GAL-2 governs how applications consume it before it becomes state.

Why it matters

Raw time can become application state silently.

GAL-2 gives applications a governed boundary before time is trusted, written, ordered, logged, or committed.

Without GAL-2

Timing faults can pass straight into production.

Backward clock steps can break ordering.
Stale references can be consumed as normal.
Recovery events can shock the application.
Dashboards may detect the issue after bad time was already committed.

With GAL-2 Time Contract

Time is governed before the application trusts it.

Applications consume gal2_time instead of raw time.
Monotonic behavior is preserved for contract consumers.
GAL-2 can enter bounded holdover when policy allows.
Controlled rejoin and fail-closed behavior protect committed state.

Runs on AWS Billing by Stripe Assets on Amazon S3

Time-boundary failures

Built for the moments where time breaks software.

GAL-2 Time Contract is designed for application paths that cannot blindly trust raw time during discontinuities, legacy timestamp boundaries, reference loss, stale time, recovery events, or timing behavior that can corrupt ordering and committed state.

Leap-second-like discontinuities

Do not let time jumps become state.

Leap seconds and similar discontinuities can create brittle application behavior when software assumes raw time is always safe. GAL-2 gives protected applications a governed path through gal2_time, validity, mode, reason, sequence, and fail-closed semantics.

Y2038 and legacy boundaries

Govern the edge before legacy time fails.

Y2038-style failures happen when legacy consumers cannot safely handle raw timestamp boundaries. GAL-2 can be evaluated as a governed consumption layer for selected legacy workflows, mediating how time reaches the application instead of exposing brittle consumers directly to raw time.

Reference loss and recovery

Hold, rejoin, or fail closed.

When upstream timing becomes stale, unavailable, degraded, or returns out of phase, GAL-2 can preserve bounded monotonic continuity where policy allows, perform controlled rejoin, or stop protected operations before unsafe time becomes committed state.

Claim boundary: GAL-2 does not claim to remove leap seconds from UTC or universally fix every Y2038-vulnerable system. It governs application consumption of time so discontinuities and legacy time-boundary behavior can be handled through policy, contract state, and controlled output.

GAL-2™ Time Contract

Download the application-facing Time Contract.

GAL-2 Time Contract RC3.1 is a local daemon that exposes gal2_time and runtime contract semantics for applications that need governed time consumption, bounded holdover, controlled rejoin, and fail-closed behavior.

Precision protects the reference. GAL-2 protects the consumer.

Primary local endpoint http://127.0.0.1:9095/contract

Release status Limited Availability evaluator release

Evaluator notice

RC3.1 is intended for developer pilots, architecture review, controlled technical validation, and non-production evaluation. Activation requires a valid GAL-2 API key.

This release is provided AS IS and AS AVAILABLE. It is not certified for production critical infrastructure, safety-critical systems, regulated trading, medical systems, aviation, emergency services, life-support systems, nuclear facilities, weapons systems, or other high-risk environments without a separate written agreement with GAL-2 Technologies LLC.

Download for macOS Download for Linux

macOS SHA256 Linux SHA256 Linux GPG signature Linux public key

What applications consume

Applications call the local Time Contract and consume gal2_time with safe_to_consume, valid_until, mode, reason, monotonic_sequence, and source_lineage.

Contract behavior

The contract can operate in LIVE, DEGRADED, HOLDOVER, REJOIN, WARMING, or FAIL_CLOSED. When policy can no longer justify safe consumption, protected operations should not proceed through the GAL-2 contract path.

Architecture boundary

The local daemon is the contract layer. The GAL-2 API and protected core remain upstream. The daemon reconciles with the API when available, preserves local continuity when policy allows, and exposes governed time before applications commit state.

Claim boundary

GAL-2 Time Contract does not replace UTC, GNSS, PTP, NTP, TAI, chrony, atomic clocks, grandmasters, or timing receivers. It complements them at the application boundary.

Quickstart for macOS

Install the notarized macOS package, add your GAL-2 API key, restart the LaunchDaemon, and verify the local Time Contract.

1. Install the macOS package

Open GAL2-TimeContract-RC31-macos-arm64-founder-notarized.pkg and complete the installer.

2. Add your API key

printf "Enter GAL-2 API key: "
stty -echo
IFS= read -r GAL2_API_KEY
stty echo
printf "\n"

sudo mkdir -p /usr/local/gal2/config
printf "GAL2_API_KEY=%s\nGAL2_API_URL=https://api-v2.gal-2.com/time\nGAL2_BIND_HOST=127.0.0.1\nGAL2_BIND_PORT=9095\n" "$GAL2_API_KEY" | sudo tee /usr/local/gal2/config/daemon.env >/dev/null
sudo chmod 600 /usr/local/gal2/config/daemon.env
sudo chown root:wheel /usr/local/gal2/config/daemon.env
unset GAL2_API_KEY

3. Restart the daemon

sudo launchctl kickstart -k system/com.gal2.daemon

4. Check status

curl -s http://127.0.0.1:9095/status | python3 -m json.tool

5. Check the local Time Contract

curl -s http://127.0.0.1:9095/contract | python3 -m json.tool

6. Run GAL-2 Doctor

/usr/local/gal2/bin/gal2-doctor-rc3/gal2-doctor-rc3 --base-url http://127.0.0.1:9095

Expected after activation

"schema": "gal2-daemon-time-contract-v1"
"version": "1.0.0-contract-rc3"
"mode": "LIVE"
"safe_to_consume": true
"reason": "fresh_api_sync"

After install or restart, the daemon may briefly return REJOIN with reason controlled_rejoin_slew_active. That is expected. GAL-2 is reconciling without stepping time backward.

Quickstart for Linux

Download the signed Linux release, verify SHA256 and GPG signature, extract, install, activate, and verify the local Time Contract.

1. Download the release and verification files

curl -O https://gal2-marketplace-assets.s3.amazonaws.com/public/time-contract/v1.0.0-rc3.1/downloads/linux/GAL2-TimeContract-RC31-linux-installer-friendly-20260504.tar.gz
curl -O https://gal2-marketplace-assets.s3.amazonaws.com/public/time-contract/v1.0.0-rc3.1/downloads/linux/GAL2-TimeContract-RC31-linux-installer-friendly-20260504.tar.gz.sha256.txt
curl -O https://gal2-marketplace-assets.s3.amazonaws.com/public/time-contract/v1.0.0-rc3.1/downloads/linux/GAL2-TimeContract-RC31-linux-installer-friendly-20260504.tar.gz.asc
curl -O https://gal2-marketplace-assets.s3.amazonaws.com/public/time-contract/v1.0.0-rc3.1/downloads/linux/GAL2_RC31_LINUX_RELEASE_PUBLIC_KEY.asc

2. Verify SHA256

shasum -a 256 GAL2-TimeContract-RC31-linux-installer-friendly-20260504.tar.gz
cat GAL2-TimeContract-RC31-linux-installer-friendly-20260504.tar.gz.sha256.txt

Expected SHA256

3c0eb646e0c95ce9c7344c1b742b6bf4039a2d1b82dd1d192fdf2a2735190eb2

3. Verify GPG signature

gpg --import GAL2_RC31_LINUX_RELEASE_PUBLIC_KEY.asc
gpg --verify GAL2-TimeContract-RC31-linux-installer-friendly-20260504.tar.gz.asc GAL2-TimeContract-RC31-linux-installer-friendly-20260504.tar.gz

4. Extract and install

tar -xzf GAL2-TimeContract-RC31-linux-installer-friendly-20260504.tar.gz
cd GAL2_TimeContract_RC31_LINUX_INSTALLER_FRIENDLY_20260504
sudo ./scripts/install.sh

5. Activate with API key

sudo ./scripts/activate.sh

6. Check status

curl -s http://127.0.0.1:9095/status | python3 -m json.tool

7. Check the local Time Contract

curl -s http://127.0.0.1:9095/contract | python3 -m json.tool

8. Run GAL-2 Doctor

/usr/local/gal2/bin/gal2-doctor --base-url http://127.0.0.1:9095

Expected after activation

mode: LIVE
reason: fresh_api_sync
safe_to_consume: true

Without an API key and without cache, Linux should report WARMING, reason warming_no_cache, and safe_to_consume=false.

Bounded application-facing continuity

Designed to preserve ordering, continuity, and safe consumption behavior under degraded timing conditions.

Monotonic application-facing continuity

GAL-2 preserves continuous, monotonic time for applications across live, holdover, rejoin, and forced daemon restarts.

Built for continuity, ordering, and resilience under degraded timing conditions.

Works with Existing Timing Stacks

Seamless Integration

Designed to complement infrastructures using NTP, GNSS, distributed applications, and modern digital systems

Technical Support

Expert Assistance

Direct technical guidance for deployment, testing, and integration

Preserve continuity, ordering, and resilience across modern distributed systems with software-defined temporal governance.

Validation Evidence

Red Light Test v2

Raw time keeps going. GAL-2 knows when to stop.

The Red Light Test demonstrates the difference between an application that consumes raw time and an application that commits state through the GAL-2 Time Contract.

The test is not a clock-accuracy claim. It shows application-facing consumption control: when time becomes unsafe, the GAL-2 contract path can block protected operations before unsafe time becomes committed state.

Raw time path Time keeps moving, even when it should not be trusted.

GAL-2 contract path Applications consume gal2_time only through governed contract semantics.

The Time Contract does not only ask:

What time is it?

It asks the operational question:

Can this governed time safely become application state right now?

Raw application

Committed through unsafe time

21 total commits

6 unsafe commits

GAL-2-aware application

Governed before commit

15 allowed commits

6 unsafe operations blocked

0 unsafe commits

Result: PASS

The GAL-2 path preserved the contract boundary: allowed safe operations, blocked unsafe ones, and produced auditable contract behavior.

Precision protects the reference. GAL-2 protects the consumer.

Your timing stack delivers time. GAL-2 governs how applications consume it before it becomes state.

Claim Boundary

What GAL-2 proves, and what it does not claim.

GAL-2 Time Contract is evaluated as an application-facing temporal governance layer. The focus is governed consumption behavior, not replacing the global timing stack.

Not claimed

Not a metrology certification.
Not a nanosecond or microsecond accuracy claim.
Not a replacement for UTC, GNSS, PTP, NTP, chrony, TAP, atomic clocks, grandmasters, or timing receivers.
Not a claim that upstream time becomes more precise.

Demonstrated focus

Application-facing Time Contract behavior.
Governed consumption of gal2_time.
Monotonic continuity for contract consumers.
Bounded holdover, controlled rejoin, and fail-closed semantics under policy.
Auditable runtime fields: mode, reason, validity, sequence, and lineage.

Keep your timing stack. Add GAL-2 where time becomes application state.

Evidence status

Public asset package created, scanned, hashed, and sealed locally.

Package SHA256:
0d74fd26dc0d62b6c812cc940b9a020ef9f142852d7e33f898ec1bc300f81aae

Public name scan: PASS
Public secret scan: PASS
Package hash verification: OK
‍

Governed time consumption.

Time delivered by your stack. Safety governed by GAL-2.

Application-Facing Time Boundary

Applications consume gal2_time through a Time Contract before raw time becomes trusted state.

Works With Existing Timing

Complements GNSS, PTP, NTP, chrony, grandmasters, cloud systems, blockchain, IoT, and distributed applications.

Bounded Continuity

When upstream time degrades, GAL-2 can preserve monotonic behavior through policy-limited holdover and controlled rejoin.

Fail-Closed Protection

When GAL-2 cannot justify safe consumption, protected state-changing operations should block or defer instead of trusting unsafe time.

image of video editing software on a computer screen

image of studio atmosphere (game development company)

Time correction, redefined

Drift-managed continuity under isolation

GAL-2 preserves governed application-facing continuity when upstream timing becomes degraded, unavailable, or isolated. The output remains bounded, labeled, and policy-aware.

THE MODEL BEHIND GOVERNED TIME

Continuity across partitions

A protected mathematical model helps maintain temporal continuity across distributed partitions, while the Time Contract exposes mode, validity, reason, sequence, and lineage to the application.

LEGACY TO MODERN

Seamless application integration

Integrates through a local daemon and API-backed contract path, allowing existing systems to consume governed time without replacing GNSS, PTP, NTP, chrony, or current infrastructure.

SECURITY AT THE CONTRACT BOUNDARY

Protected access to governed time

API-key activation, local contract delivery, signed release artifacts, verification hashes, and controlled evaluator scope support secure technical review.

image of teacher using a smartboard for edtech

Stop unsafe commits before they happen

When timing conditions degrade, GAL-2 helps protected applications block, defer, or fail closed before unsafe timestamps become committed state.

Recover without raw time shock

When the reference returns, GAL-2 supports controlled rejoin so applications are not forced to consume abrupt recovery behavior directly.

Application-facing temporal governance

Continuity under real timing stress

GAL-2 helps protected applications preserve continuity, ordering, and resilience across LIVE, HOLDOVER, REJOIN, FAIL_CLOSED, and restart conditions through an application-facing Time Contract.

What is the core benefit?

GAL-2 helps applications consume governed time instead of raw time, reducing the risk that unsafe timing conditions become committed state.

How does GAL-2 govern time consumption?

GAL-2 uses a protected fractal time model behind the API and exposes the result as gal2_time through a local Time Contract. The contract carries mode, validity, reason, sequence, and lineage so applications can act under governed semantics.

What happens when timing degrades?

GAL-2 can enter bounded holdover, preserve monotonic behavior for contract consumers, perform controlled rejoin when the reference returns, or move toward FAIL_CLOSED when safe consumption can no longer be justified.

Who should use this solution?

GAL-2 is designed for teams operating distributed applications where ordering, ledgers, logs, caches, authorization, workflows, or audit trails depend on safe time consumption.

Is integration straightforward?

Yes. GAL-2 integrates through a local daemon and API-backed contract path, complementing existing GNSS, PTP, NTP, chrony, cloud, blockchain, and IoT infrastructure.

About the Creator

Francisco Edgardo Torres Alvarado, known as Galdo, is the founder and inventor of GAL-2™, Global Alignment Layer | Fractal Time. From Puerto Rico, he leads the vision behind a new class of temporal technology built to align digital systems with governed, coherent, and verifiable time.

GAL-2™ is a technology born to correct the relationship between humanity, machines, and time.

For technical evaluation, that vision is expressed as a verifiable Time Contract that lets software evaluate time before it acts, with bounded drift, continuously corrected, publicly witnessed behavior.

Professional Scope

As founder and executive architect of GAL-2™, Francisco directs the technology stack from the production API and local daemon to Apple Developer distribution, release signing, controlled validation, patent strategy, copyrights, and trade secret protection. Every layer is designed to preserve originality, security, continuity, and verifiability.

Mission Statement

GAL-2™ exists to correct how digital systems consume time. Its mission is to reduce harmful drift, expose temporal risk before applications act, and create a bridge between machine time, governed software behavior, and the deeper natural order reflected in solar cycles. The goal is not only precision, but alignment.

Technical Expression

GAL-2™ is currently expressed through a production API and a local Time Contract daemon. The daemon exposes application-facing states such as LIVE, DEGRADED, HOLDOVER, REJOIN, WARMING, and FAIL_CLOSED, allowing software to determine whether time is safe to consume before committing an action.

Core Philosophy

Every element in GAL-2™ reflects the belief that technology should expand awareness, not reduce it. The system's fractal architecture mirrors the principle that the part contains the whole, with each module carrying the larger purpose of alignment between mathematics, machines, nature, and meaning.

Leadership Approach

Francisco leads GAL-2™ with discipline, conviction, and a long-range vision. His work combines technical execution with a human mission: to help organizations experience time not merely as a background signal, but as a governed medium of trust, continuity, and truth.

GAL-2™ | Global Alignment Layer | Fractal Time

A creation guided by the Living 5.