A deterministic, protocol-extensible execution layer
for distributed-native systems.
ENTENCY is a system-level architecture that integrates:
- A unified workstation runtime
- A distributed chunk-based node network
- A programmable protocol layer
- Deterministic multi-platform release infrastructure
It is not a browser.
It is not a node.
It is not a hosting layer.
It is an execution model.
This repository serves as the public entry point to the ENTENCY ecosystem.
The internet evolved in layers:
- Transport (HTTP)
- Rendering (Browsers)
- Compute (Cloud)
- Distribution (CDN / P2P)
Each solved a problem.
Each introduced fragmentation.
Execution, protocol, storage, and distribution are isolated stacks.
ENTENCY unifies them into a single deterministic architecture.
The goal is not to replace the web.
The goal is to evolve its execution foundation.
ENTENCY consists of two tightly coupled subsystems:
Responsibilities
- Session lifecycle management (FSM-based)
- Protocol routing engine
gns://resolution- Local runtime isolation boundary
- Distributed node communication
- Integrated execution surface
ENTENCY UP controls state, protocol, and session integrity.
Responsibilities
- Distributed chunk storage
- Content fragmentation and deterministic reassembly
- Cross-node streaming
- Node identity model
- Fault-tolerant routing
- Execution layer abstraction
GNS controls distribution and reconstruction.
+---------------------------------------------------------+
| ENTENCY UP |
| |
| +-------------------+ +------------------------+ |
| | Session FSM | --> | Protocol Router | |
| +-------------------+ +------------------------+ |
| | | |
| v v |
| Runtime Layer gns:// Handler |
| | | |
+------------+-------------------------+------------------+
|
v
+---------------------------------------------------------+
| ENTENCY GNS (Node Layer) |
| |
| +----------------+ +------------------------------+ |
| | Node Runtime |<->| Distributed Chunk Network | |
| +----------------+ +------------------------------+ |
| | | |
| v v |
| Storage Layer Execution Layer |
+---------------------------------------------------------+
Design Principle
Deterministic control at the top.
Distributed reconstruction at the bottom.
gns://protocol resolution- Local node integration
- Embedded GNS binary per platform
- Windows x64 packaging
- Linux x64 packaging
- Linux ARM64 packaging
- Deterministic CI build pipeline
- Version-locked runtime ↔ node coupling
- Chunk-based streaming reconstruction
- Session-driven navigation
The roadmap is architecture-driven.
Each phase represents structural evolution — not feature addition.
Establish deterministic runtime control and reproducible platform builds.
- Workstation runtime foundation
- Session FSM lifecycle engine
- Protocol routing framework
gns://handler- Local runtime isolation boundary
- UI system architecture
- Cross-platform rendering layer
- Local node runtime
- Basic chunk storage model
- Initial streaming support
- Runtime binary integration into UP
- Multi-architecture packaging
(Windows x64 / Linux x64 / Linux ARM64) - Deterministic CI builds
- Unified release pipeline
- Embedded node version locking
Deliverable
Stable workstation runtime coupled with a local GNS node across supported platforms.
Transition from local-node validation to distributed multi-node architecture.
- Cross-node chunk distribution model
- Deterministic chunk hashing
- Integrity verification pipeline
- Multi-source chunk retrieval strategy
- Node discovery protocol
- Peer handshake model
- Fault-tolerant chunk reassembly
- Distributed streaming buffer synchronization
- Content fragmentation engine
- Adaptive bandwidth routing
- Node-level resource allocation control
- Distributed storage abstraction
- Execution scheduling primitives
- Node identity structure
- Signed chunk verification
- Session-level trust boundaries
- Protocol isolation enforcement
- Deterministic build verification
- Artifact integrity validation
- Runtime-node compatibility enforcement
Deliverable
Reliable distributed chunk-based streaming and hosting across multiple nodes.
Expand ENTENCY into a programmable protocol ecosystem.
- Extended
gns://capabilities - Protocol extension registry
- Unified protocol negotiation engine
- Secure protocol sandbox model
- Runtime capability discovery
- Deterministic resource metering abstraction
- Execution cost modeling
- Node participation accounting layer
- Incentive modeling groundwork
- Deterministic usage tracking
- Adaptive routing decisions
- Node performance profiling
- Smart chunk prioritization
- Runtime load balancing logic
- Predictive buffer optimization
- SDK groundwork
- Node interaction API
- Local development node toolkit
- Protocol documentation framework
Deliverable
Programmable distributed execution runtime with protocol-level extensibility.
Transform ENTENCY into a full distributed execution platform.
- Multi-workspace architecture
- Advanced session orchestration
- Integrated node dashboard
- Visual network topology viewer
- Developer console layer
- Large-scale distributed deployment model
- Cross-region node clustering
- Edge-device orchestration (ARM boards)
- Automated node provisioning tools
- Monitoring abstraction layer
- Public SDK release
- Plugin architecture foundation
- Stable / experimental release channels
- Documentation portal
- Integration guides
- Signed binaries across platforms
- Release automation hardening
- Long-term support strategy
- Opt-in telemetry model
Deliverable
Unified distributed execution platform accessible through ENTENCY UP.
- Deterministic builds
- Architecture-first engineering
- Runtime–node version coupling
- Separation of control and execution layers
- Protocol-level extensibility
- Reproducibility over convenience
Infrastructure defines possibility.
Browsers defined access.
Cloud defined scale.
Distributed systems redefine trust.
ENTENCY explores what happens when execution, protocol, and distribution are unified under a single deterministic runtime.
Core engine remains closed during active foundational development.