Build once, run anywhere.
Connect all operating systems and programming languages through one reproducible, offline-first runtime.

Learn more about the ecosystem:
PAXECT Universal Bridge ›

Looking for the full bundle (Core + plugins + demos)?
See PAXECT Core Complete →

Status: v1.0.0 — Initial Public Release — October 22, 2025

Deterministic, offline-first, and reproducible — built for secure data pipelines and NIS2-ready digital hygiene.

PAXECT Polyglot provides secure, deterministic interoperability across languages, runtimes, and operating systems. It’s a reproducible, verifiable data bridge between Python, Node.js, and Go, extensible to any runtime through a common binary interface powered by PAXECT Core.

Plug-and-play: zero dependencies, no vendor lock-in, and cross-OS reproducibility. No cloud, no AI heuristics — just byte-for-byte deterministic transport with checksum-verified integrity (CRC32 + SHA-256).

PAXECT Polyglot is a multi-language bridge enabling lossless, reproducible data exchange between heterogeneous runtimes. It ensures that both binary and textual data remain bit-identical when transferred between languages, platforms, and operating systems.

Unlike traditional serialization frameworks — JSON, Protobuf, MsgPack — which introduce drift, rounding, or type loss, Polyglot uses the PAXECT Core container format to guarantee checksum-verified integrity and deterministic reproducibility.

It acts as the glue layer between analytical systems, edge devices, and enterprise runtimes — allowing Python pipelines, Go microservices, and Node.js orchestration layers to communicate reproducibly and securely.

• Cross-Language Consistency — deterministic I/O between Python · Node.js · Go
• Integrity-Checked Transport — CRC32 + SHA-256 verification
• No-AI / No-Heuristics Policy — deterministic, auditable behavior
• Self-Contained Binary Bridge — no external runtime dependencies
• Cross-OS Reproducibility — identical output on Linux · macOS · Windows · Android · iOS
• Polyglot Extensibility — easily embeddable in Rust, C++, Java, or Swift environments

Operating Systems

Languages

This suite validates the PAXECT Polyglot Plugin, ensuring:

• Deterministic behavior across platforms and languages
• UTF-8 strictness and proper error recovery
• CI/CD-safe fail-and-recover cycles
• Round-trip reproducibility (upper/lower/text transforms)
• Continuous operation under sustained load

# Clone the Polyglot repository
git clone https://github.com/paxect/paxect-polyglot.git
cd paxect-polyglot

# (Optional) create a virtual environment
python3 -m venv .venv && source .venv/bin/activate

# No extra dependencies required (stdlib-only)
python paxect_polyglot_plugin.py --mode health && echo "OK"

🪟 Windows tip: Replace python3 with py -3 or python depending on your environment.

All demos are deterministic, self-contained, and safe to run locally or in CI.

Run all demos sequentially:

for d in demos/demo_*; do
  echo "Running $d ..."
  chmod +x "$d"
  "$d"
done

Simulates a corrupted UTF-8 file (0xff byte) to trigger a decode failure, then runs a valid file immediately after to confirm recovery.

Expected Output:

returncode: 2
error: utf-8 decode failed: invalid start byte
[+] Recovery OK — output: POLYGLOT RECOVERY WORKS
✅ Self-recovery confirmed

Log: /tmp/paxect_demo11_polyglot/polyglot_recover.log

Runs continuous upper → lower transform cycles for 60 seconds.

Expected Output:

Completed cycles : ~2900+
Errors detected  : 0
Reliability      : 100.0000%
✅ Polyglot engine passed 1-minute stress test without errors

Log: /tmp/paxect_demo12_polyglot/polyglot_stress.jsonl

paxect-polyglot-plugin/
├── paxect_polyglot_plugin.py     # Standalone UTF-8 deterministic engine
├── demos/                        # Enterprise demos 0–12
│   ├── demo_11_fail_and_recover_polyglot.py
│   └── demo_12_stress_test_polyglot.py
└── README.md                     # This document

Each Polyglot operation guarantees:

• Deterministic I/O: identical text in = identical text out

• UTF-8 strict decoding: no silent corruption

• Zero-telemetry: fully offline operation

• Exit codes

  • 0 = OK
  • 2 = I/O or UTF-8 error
  • 3 = Argument error

✅ 12/12 demos completed successfully on Ubuntu 24.04 LTS (x86_64) using Python 3.12.3 / GCC 13.3.0. All results reproduced bit-identically across Linux, macOS, and Windows.

paxect-polyglot-plugin/
├── paxect_polyglot_plugin.py     # Main CLI + API bridge
├── demos/                        # Cross-OS & language demos
├── tests/                        # Automated verification suite
├── coverage_run.sh               # Coverage script (pytest)
├── pytest.ini                    # Pytest configuration
└── README.md                     # This document

Requirements: Python ≥ 3.10, Node.js ≥ 18, Go ≥ 1.20

# Clone repository
git clone https://github.com/<your-org>/paxect-polyglot-plugin.git
cd paxect-polyglot-plugin

# Virtual environment
python3 -m venv .venv
source .venv/bin/activate

# Install dependencies
python3 -m pip install -r requirements.txt

python3 paxect_polyglot_plugin.py --mode health

Expected output:

[OK] PAXECT Polyglot Plugin operational.

Verify deterministic bridge:

python3 paxect_polyglot_plugin.py --mode test -i input.txt -o output.txt
sha256sum input.txt output.txt

All tests conform to the PAXECT deterministic testing standard.

Run test suite:

python3 -m pytest -v

Run with coverage:

./coverage_run.sh

Sample output:

Name                           Stmts   Miss  Cover
-------------------------------------------------
paxect_polyglot_plugin.py        228      5    97%
-------------------------------------------------
TOTAL                            228      5    97%

GitHub Actions Example

jobs:
  polyglot-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      - name: Run Polyglot Tests
        run: ./coverage_run.sh

Python ─┬─► Node.js ─┬─► Go
         │            │
         ▼            ▼
     Deterministic  Deterministic
      PAXECT Core    PAXECT Core

Each hop validates CRC32, SHA-256, and container version fields for reproducibility.

PAXECT is built to stay free and open-source at its core.
At the same time, we recognize the need for a sustainable model to fund long-term maintenance and enterprise adoption.

• Core stays free forever — no lock-in, no hidden fees.
• Volunteers and researchers: always free access to source, builds, and discussions.
• Transparency: clear dates, no surprises.
• Fairness: individuals stay free; organizations that rely on enterprise features contribute financially.

• Launch phase: starting from the official PAXECT product release date, all modules — including enterprise — will be free for 6 months.
• This free enterprise period applies globally, not per individual user or download.
• 30 days before renewal: a decision will be made whether the free enterprise phase is extended for another 6 months.
• Core/baseline model: always free with updates. The exact definition of this baseline model is still under discussion.

• Motivation: volunteers know their work has impact and will remain accessible.
• Stability: enterprises get predictable guarantees and funded maintenance.
• Sustainability: ensures continuous evolution without compromising openness.

Bug or feature request? Open an Issue ›

General questions or collaboration ideas? Join the Discussions ›

We actively review proposals and merge validated ideas into the PAXECT roadmap.

If PAXECT Polyglot plugin helped your research, deployment, or enterprise project,
please consider giving the repository a Star on GitHub —
it helps others discover the project and supports long-term maintenance.

PAXECT Polyglot is maintained as a verified enterprise plugin. Sponsorship enables continuous cross-language verification and deterministic QA across operating systems.

Enterprise partnership options:

• Cross-language integration validation
• Secure data reproducibility compliance
• CI/CD and interoperability certification

How to get involved

• Become a GitHub Sponsor

Contact: sponsor@PAXECT-Team@outlook.com

enterprise@PAXECT-Team@outlook.com

• Ownership: All PAXECT products and trademarks (PAXECT™ name + logo) remain the property of the Owner.
• License: Source code is Apache-2.0; trademark rights are not granted by the code license.
• Core decisions: Architectural decisions and final merges for Core and brand-sensitive repos require Owner approval.
• Contributions: PRs are welcome and reviewed by maintainers; merges follow CODEOWNERS + branch protection.
• Naming/branding: Do not use the PAXECT name/logo for derived projects without written permission; see TRADEMARKS.md.

✅ Deterministic · Reproducible · Cross-Language · Offline

© 2025 PAXECT Systems. Deterministic interoperability for the modern multi-language enterprise

Status: v1.0.0 — Initial Public Release — October 22, 2025

The curated PAXECT bundle: Core + AEAD Hybrid + Polyglot + SelfTune + Link — with 10 integrated demos, observability, and deterministic performance across OSes.

What it is: the official reference implementation of the PAXECT ecosystem — a verified, reproducible, cross-OS runtime that showcases the multi-OS bridge and in-freq multi-channel architecture in real workflows.

• Unified Ecosystem: Core + AEAD + SelfTune + Polyglot + Link in one deterministic bundle
• Reproducibility: bit-identical behavior across Linux, macOS, Windows (best-effort: BSD, mobile shells)
• Offline-first: zero telemetry, no network dependencies
• Enterprise-ready: 10 reproducible demo pipelines, audit trail, and metrics endpoints
• Zero-AI Runtime: SelfTune provides adaptive guardrails without ML or heuristics (no cloud)

• PAXECT Core is a stand-alone OS-level deterministic bridge (plugin-capable).
• PAXECT Core Complete is the curated bundle that includes Core plus the official plugins and demo suite.
  Use Core when you want a minimal, plug-and-play bridge.
  Use Core Complete when you want the full experience (plugins + demos) out of the box.

• Python 3.9 – 3.12 (recommended 3.11+)
• Works on Linux, macOS, Windows, FreeBSD, OpenBSD, Android (Termux), and iOS (Pyto).
• No external dependencies or internet connection required — fully offline-first runtime.

Some demos use these standard tools if available:

• bash (for demo_05_link_smoke.sh)
• dos2unix (for normalizing line endings)
• jq (for formatting JSON output)

git clone https://github.com/PAXECT-Interface/paxect-core-complete.git
cd paxect-core-complete
python3 -m venv venv
source venv/bin/activate      # on Windows: venv\Scripts\activate
pip install -e .

Verify the deterministic core import:

python3 -c "import paxect_core; print('PAXECT Core OK')"

Then run any of the integrated demos from the demos/ folder to validate deterministic reproducibility.

paxect-core-complete/
├── paxect_core.py
├── paxect_aead_hybrid_plugin.py
├── paxect_polyglot_plugin.py
├── paxect_selftune_plugin.py
├── paxect_link_plugin.py
├── demos/
│   ├── demo_01_quick_start.py
│   ├── demo_02_integration_loop.py
│   ├── demo_03_safety_throttle.py
│   ├── demo_04_metrics_health.py
│   ├── demo_05_link_smoke.sh
│   ├── demo_06_polyglot_bridge.py
│   ├── demo_07_selftune_adaptive.py
│   ├── demo_08_secure_multichannel_aead_hybrid.py
│   ├── demo_09_enterprise_all_in_one.py
│   └── demo_10_enterprise_stability_faults.py
├── test_paxect_all_in_one.py
├── ENTERPRISE_PACK_OVERVIEW.md
├── SECURITY.md
├── CONTRIBUTING.md
├── CODE_OF_CONDUCT.md
├── TRADEMARKS.md
├── LICENSE
└── .gitignore

Plug-and-play: Core operates standalone, with optional plugins attachable via flags or config. Deterministic behavior remains identical across environments.

Run reproducible demos from the repository root:

python3 demos/demo_01_quick_start.py
python3 demos/demo_02_integration_loop.py
python3 demos/demo_03_safety_throttle.py
python3 demos/demo_04_metrics_health.py
bash    demos/demo_05_link_smoke.sh
python3 demos/demo_06_polyglot_bridge.py
python3 demos/demo_07_selftune_adaptive.py
python3 demos/demo_08_secure_multichannel_aead_hybrid.py
python3 demos/demo_09_enterprise_all_in_one.py
python3 demos/demo_10_enterprise_stability_faults.py

All demos generate structured JSON audit logs under /tmp/, verifiable through deterministic SHA-256 outputs.

Internal pytest suites validate core reproducibility. End-users can rely on the integrated demo suite (01–10) for deterministic verification. Each demo reports performance, checksum validation, and exit status cleanly.

• Default mode: offline, zero telemetry.
• Sensitive configuration via environment variables.
• AEAD Hybrid is simulation-grade; for production, integrate with verified crypto or HSM.
• Adheres to Digital Hygiene 2027 and NIS2 security standards.
• Follows responsible disclosure in SECURITY.md.

See ENTERPRISE_PACK_OVERVIEW.md for extended features and enterprise integration roadmap.

Includes:

• HSM / KMS / Vault integration
• Extended policy and audit engine
• Prometheus, Grafana, Splunk, and Kafka observability connectors
• Deployment assets (systemd, Helm, Docker)
• Compliance documentation (ISO · IEC · NIST · NIS2)

• License: Apache-2.0
• Ownership: All PAXECT trademarks and brand assets remain property of the Owner.
• Contributions: PRs welcome; feature branches must pass deterministic CI pipelines.
• Core merges: Require owner approval for brand or architecture-sensitive changes.
• Community Conduct: See CODE_OF_CONDUCT.md

Join as a maintainer or contributor — see CONTRIBUTING.md for details.

PAXECT Core Complete follows an open contribution and verification-first model:

• No fixed release schedule — determinism prioritized over speed.
• Verified updates only, across OSes and environments.
• Maintainers focus on innovation, reproducibility, and architecture quality.

PAXECT Core Complete is a verified, plug-and-play runtime ecosystem unifying all PAXECT modules. Sponsorships fund ongoing cross-platform validation, reproducibility testing, and audit compliance for deterministic and secure data pipelines across Linux, Windows, and macOS.

• Infrastructure validation and multi-OS QA
• Deterministic CI/CD performance testing
• OEM and observability integration partnerships
• Extended reproducibility assurance for regulated industries

• Become a GitHub Sponsor
• Enterprise or OEM inquiries: enterprise@PAXECT-Team@outlook.com

Sponsorships help sustain open, verifiable, and enterprise-ready innovation.

• Ownership: All PAXECT products and trademarks (PAXECT™ name + logo) remain the property of the Owner.
• License: Source code under Apache-2.0; trademark rights are not granted by the license.
• Core decisions: Architectural merges for Core and brand repos require Owner approval.
• Contributions: PRs reviewed under CODEOWNERS and branch protection.
• Brand Use: Do not use PAXECT branding for derivatives without written permission. See TRADEMARKS.md.

PAXECT Core Complete is free and open-source at its foundation. Sustainable sponsorship ensures long-term maintenance, reproducibility, and enterprise adoption.

• Core remains free forever — no vendor lock-in.
• Full transparency, open changelogs, and audit-ready releases.
• Global 6-month free enterprise window after public release.
• Community-driven decision-making on renewals and roadmap.

• Motivates contributors with lasting value.
• Ensures reproducible stability for enterprises.
• Balances open innovation with sustainable funding.

PAXECT-Team@outlook.com 💬 Issues 💭 Discussions

For security disclosures, please follow responsible reporting procedures.

Copyright © 2025 PAXECT Systems — All rights reserved.