🌍

Global precision

Fractal drift-corrected time for worldwide alignment across apps, services, and devices.

⚡

Enterprise-grade

Scalable infrastructure on AWS, low-latency endpoints, and hardened service boundaries.

🔐

Secure by design

API keys, usage plans, Stripe billing, and least-privilege policies. Compliance-ready.

How it works

Run the GAL-2 Time Contract daemon locally.
Connect your application to the local /contract endpoint.
Receive governed time plus an application-facing safety decision.
Act only when safe_to_consume is true.

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

GAL-2 Time Contract answers two questions:

What time is it?

Is this time safe for the application to consume?

Your timing stack delivers time. GAL-2 tells your applications whether that time is safe to use.

Runs on AWS Billing by Stripe Assets on Amazon S3

GAL-2™ | Time Contract

GAL-2™ Time Contract RC3.1

A local application-facing time contract for software systems that need governed time consumption, explicit holdover policy, local continuity, and controlled rejoin behavior. Free download. Activation requires a valid GAL-2 API key.

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

GAL-2 Time Contract RC3.1 is a Limited Availability release intended for developer pilots, architecture review, and non-production technical evaluation. The macOS package is Developer ID signed, Apple notarized, stapled, Gatekeeper accepted, public-download verified, and updated with a postinstall step that starts or restarts the local LaunchDaemon automatically. The Linux installer-friendly release is GPG signed, public-download verified, and validated through Ubuntu 24.04 Docker no-key and API activation tests.

Last updated: May 4, 2026

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

RC3.1 status: macOS ships as a standalone notarized runtime with no external Python prerequisite. Linux now ships as an installer-friendly evaluator package with install, activation, uninstall, systemd service, legal notices, GPG signature, and Docker validation evidence.

Limited Availability evaluator notice

By downloading, installing, copying, testing, or using GAL-2 Time Contract RC3.1, you acknowledge that this is a Limited Availability evaluator release for controlled technical validation, architecture review, developer pilots, and non-production review only. It is provided AS IS and AS AVAILABLE, without warranties of merchantability, fitness for a particular purpose, non-infringement, accuracy, availability, continuity, security, or suitability for any particular system.

GAL-2 Time Contract RC3.1 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 it does

GAL-2 Time Contract exposes a local contract that applications can read before trusting time. The contract reports mode, health, reason, safe_to_consume, valid_until, monotonic_sequence, local receive and serve timestamps, API latency, cache age, quota status, and source lineage.

Release scope

RC3.1 is intended for developer pilots, architecture review, and controlled non-production technical evaluation. It is not production critical infrastructure readiness yet, and it is not a metrology claim. It is an application-facing temporal governance contract release that wraps the GAL-2 API into a local consumer contract.

Architecture boundary

The daemon is the local contract layer. The GAL-2 API and protected core remain the authority. The daemon reconciles with the API whenever possible, preserves local continuity when policy allows, and exposes safe_to_consume before applications act.

Time Contract states

LIVE, DEGRADED, HOLDOVER, REJOIN, WARMING, and FAIL_CLOSED. These states help applications understand whether governed time is fresh, recovering, degraded, locally held, or unsafe to consume.

HOLDOVER policy

HOLDOVER is not a silent failure when safe_to_consume=true. It means the daemon is serving governed continuity from the last good GAL-2 API state inside explicit policy limits. If policy limits are exceeded, the contract moves toward FAIL_CLOSED and safe_to_consume=false.

Verification

macOS RC3.1 postinstall-friendly SHA256: dfb89d95c7b6efcc31c2254e781ee48bb66925e967327263767883b181ce4bc6

Linux RC3.1 installer-friendly SHA256: 3c0eb646e0c95ce9c7344c1b742b6bf4039a2d1b82dd1d192fdf2a2735190eb2

Linux GPG key ID: 2F9528A0EE6D77170B6947FF9CAB67A8AFA08B75

macOS package is Developer ID signed, Apple notarized, stapled, Gatekeeper accepted, public-download verified, and includes a postinstall step that starts or restarts the local LaunchDaemon automatically. Linux package is GPG signed, public-download verified, installer-friendly, and includes install, activation, uninstall, systemd service, legal notices, Docker no-key validation, Docker API activation validation, Doctor validation, and clean secret scan evidence.

Built for developer pilots, architecture review, controlled technical evaluation, and design-partner preparation where governed continuity, explicit holdover policy, and cloud reconciliation matter. Without a valid API key, the daemon exposes local status and WARMING semantics, but it does not serve production GAL-2 Time. GAL-2 Time Contract does not replace UTC, GNSS, PTP, NTP, TAP, chrony, atomic clocks, or timing receivers.

Quickstart for macOS

Install the notarized macOS package, add your GAL-2 API key, restart the LaunchDaemon, and verify the local Time Contract. RC3.1 does not require installing Python separately.

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. Wait about 60 to 90 seconds and check /contract again.

Quickstart for Linux Installer-Friendly Release

Download the signed Linux installer-friendly release, verify the SHA256 hash and GPG signature, extract it, install, activate with your GAL-2 API key, 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. The installer includes legal notices and requires evaluator terms acceptance before installation unless GAL2_ACCEPT_EVALUATOR_TERMS=1 is set for controlled CI or Docker evaluation.

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.

Evidence

GAL-2 Red Light Test v2

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

Modern software usually assumes that if time is moving, time is safe.

That assumption is dangerous.

When an upstream time source becomes unreachable, stale, degraded, or operationally unsafe, many applications continue committing state as if nothing happened.

GAL-2 Time Contract introduces a local application-facing safety layer.

It does not only answer:

What time is it?

It also answers:

Is this time safe for the application to consume?

Raw application

21 commits

6 unsafe commits

GAL-2-aware application

15 allowed commits

6 unsafe operations blocked

0 unsafe commits

Result: PASS

Your timing stack delivers time. GAL-2 tells your applications whether that time is safe to use.

Claim boundary

This is not a metrology claim.

This is not a nanosecond or microsecond accuracy claim.

This is not a replacement claim for UTC, GNSS, PTP, NTP, chrony, TAP, atomic clocks, or timing receivers.

This is an application-facing temporal governance demonstration.

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 alignment

Helps applications consume time through explicit safety states instead of trusting raw time blindly.

Reduces application exposure to unsafe timing conditions through governed contract states.

Seamless integration

Works with GPS, NTP, blockchain, embeded real-time systems and IoT for broad compatibility.

Continuous precision

Delivers real-time, uninterrupted accuracy for essential operations.

Enterprise-ready scalability

Supports global, high-volume deployments and complex infrastructures.

image of video editing software on a computer screen

image of studio atmosphere (game development company)

Time correction, redefined

Drift-managed continuity under isolation

Maintain correct time across systems including GPS, NTP, blockchain, and IoT. Bound drift and latency with advanced fractal correction.

A mathematical model governs temporal authority

Continuity across partitions

A proprietary mathematical model governs temporal continuity across distributed partitions, establishing deterministic real-time alignment under isolation.

Works with any system

Seamless integration, legacy to modern

Connect effortlessly with all infrastructures. Boost reliability for mission-critical operations.

Security at every layer

Encryption for trusted synchronization

Protect time data with enterprise-grade encryption and compliance. Built for secure, global uptime.

image of teacher using a smartboard for edtech

Accurate time, everywhere, always

Enhance system reliability with precise, real-time synchronization across all platforms.

Seamless global synchronization

Correct UTC drift for flawless data integrity and network performance.

Continuity under real timing stress
Software-defined temporal governance for distributed systems

GAL-2 is built to preserve continuity, ordering, and resilience across live, holdover, rejoin, and restart conditions

FAQ+

What is the core benefit?

Our system delivers unmatched time correction, ensuring seamless alignment across GPS, NTP, blockchain, and IoT networks.

How does the system achieve alignment?

GAL-2 applies a proprietary fractal time model that continuously corrects drift and preserves temporal continuity across distributed systems. Mathematical details remain part of the protected internal design.

Who should use this solution?

GAL-2 is designed for organizations operating distributed applications where continuity, ordering, and resilience matter under timing degradation or operational stress.

Is integration straightforward?

Yes. Our platform is designed for rapid deployment, supporting existing infrastructure with minimal disruption.

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.

GAL-2™ Time Contract