ENTITY Documentation Portal
Developer manual · external reproducibility

Clean-Room Implementation

Three targets must stay separate: current supported runtime = ENTITY v3.4.3; frozen external conformance target = ENTITY Protocol 1.0; six BTG-controlled language/package baselines discussed below = historical v3.4.2 evidence unless separately re-qualified.

The strongest interoperability question is whether an unrelated engineer can reproduce ENTITY semantics from public protocol material without copying the BTG reference implementation. BTG also publishes six controlled language baselines so portability and cross-language behavior can be reproduced without pretending those repositories are independent validation.

New to ENTITY vocabulary? Start with the plain-language clean-room glossary and object map. It explains terms such as vector, authority, sovereign authority, aliases and the purpose of the public object families without changing the sealed Protocol 1.0 conformance kit.
Want to inspect the controlled language artifacts? See Historical ENTITY v3.4.2 Language Distribution Readiness. Those package/module versions are intentionally preserved as v3.4.2 because that is the target they were built and qualified against.

Six BTG-controlled language baselines

These repositories are useful implementation and reproducibility references. They are controlled by Blackmore Technology Group and therefore do not count as unrelated third-party implementations. Their recorded v3.4.2 campaign results are historical/inherited evidence, not fresh v3.4.3 executions.

Rust

Native Rust baseline with the sealed v3.4.2 26-vector Global Passport campaign.

ENTITY-RUST-CLEANROOM →

TypeScript

TypeScript/Node controlled baseline corresponding to the same v3.4.2 campaign family.

ENTITY-TYPESCRIPT-CLEANROOM →

C# / .NET

.NET controlled baseline with Windows-native CI and v3.4.2 campaign evidence.

ENTITY-CSHARP-CLEANROOM →

Go

Go controlled baseline for portable language-native verification.

ENTITY-GO-CLEANROOM →

Swift

Swift controlled baseline exercised through macOS CI.

ENTITY-SWIFT-CLEANROOM →

Java

Java/Maven controlled baseline with sealed v3.4.2 campaign verification.

ENTITY-JAVA-CLEANROOM →

What unrelated evidence looks like

An unrelated implementation should control its own repository, architecture, libraries, source code, test strategy and evidence. Reading public specifications, schemas and sealed vectors is expected; importing or translating BTG implementation code defeats the strongest independence claim.

Start small: the independent classifier challenge asks an unrelated implementer to build only the sealed Global Passport classifier. A specification ambiguity, partial implementation or full convergence are all useful results.

Recommended independent path

  1. Pin the exact target: Protocol 1.0 kit, a historical v3.4.2 baseline, or a specifically defined v3.4.3 runtime experiment.
  2. Verify the applicable sealed kit/release hashes.
  3. Document every public specification/schema/vector consulted.
  4. Implement canonical parsing/serialization and required verification rules using your own design.
  5. Accept every required valid vector and reject every required invalid vector for the selected conformance target.
  6. Publish source, CI, environment and result hashes in a repository outside BTG control.
  7. If the narrow campaign converges, continue toward bidirectional live interoperability.
  8. Export sovereign state, recover it independently and verify the same conclusions where the selected target supports it.
  9. Publish failures, ambiguities and exclusions as well as passes.

Reproduce a controlled baseline first

The Rust reproduction task is a smaller step before independently authoring ENTITY. Reproducing the BTG-controlled v3.4.2 Rust campaign on another environment produces useful external reproduction evidence while remaining clearly distinct from an independently authored implementation and from a v3.4.3 runtime qualification.

What does not count as independent

BTG's Rust, TypeScript, C#, Go, Swift and Java repositories are controlled reproducibility baselines. Forking or translating one does not make the resulting work independent merely because it lives in a different repository.

Implementation freedom

A clean-room implementer may choose a different internal data model, database, cryptographic library, language or architecture. Conformance is about the externally defined semantics/results of the selected target, not matching BTG's internal code structure.

Canonical status

Canonical-status rules are versioned protocol/runtime semantics and must be evaluated against the exact target being claimed. Historical v3.4.2 canonical-status evidence must retain its v3.4.2 label; current-runtime claims must use the applicable v3.4.3 rules/evidence. In either case, canonical protocol origin/stewardship does not create ownership of downstream user identities, assets or third-party source.

Useful failure

If public material is insufficient to reproduce a decision, open a precise issue describing the ambiguity. That is protocol-quality evidence, not a failed contribution. The project should prefer a documented ambiguity or reproducible failure over weakening the clean-room boundary.

Choose an external verification path →