rt/Reticulum
1
0
Fork 0
mirror of https://github.com/markqvist/Reticulum.git synced 2026-10-25 18:40:17 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Structural cleanup

Browse source
This commit is contained in:
Mark Qvist 2026-09-19 11:16:58 +02:00
parent badd850088
commit e699bb23f1
No known key found for this signature in database
8 changed files with 974 additions and 974 deletions
Download patch file Download diff file Expand all files Collapse all files

516
docs/manual/_sources/brandolinis.rst.txt
View file

@ -732,263 +732,6 @@ I'll close this guide by stating what these standards are *not*\ : They are neit
The reference implementation has met this standard for years, and its users know what that looks like.
.. _brandolinis-prns:
The Prns Case
-------------
.. _brandolinis-purpose-and-scope:
Purpose & Scope
^^^^^^^^^^^^^^^
This section provides a concrete example, which future evaluations can use as a template. Its purpose is not to be the last word on this particular subject, but to be an example of how the ideas in this chapter can be applied, and to make the next such examination easier.
The subject of this case study is **Prns**\ , a project published at the repository ``github.com/KenAKAFrosty/Prns``\ , presented as a "ground-up implementation of Reticulum, written in Rust", marketed as faster, safer, and more strictly tested than the reference, and widely promoted with the claim of "up to 89× the throughput" of the reference implementation. The record described below is the project's own, and sourced from its GitHub repository, analyzed locally.
.. _brandolinis-project-in-brief:
The Project In Brief
^^^^^^^^^^^^^^^^^^^^
* **Time span.** 3,374 commits between 2026-05-26 and 2026-09-12: approximately 110 days,
at a mean rate of ~31 commits per day. Monthly: 132 / 1,137 / 1,097 / 805 / 203.
* **Authorship.** 3,252 of 3,374 commits (96.4%) are authored by a single account. A
second identity, "Prns Tests tests@example.test" - a fictitious identity on a reserved
domain - contributed 35 commits, every one of them website and marketing content.
* **Size.** 3,519 tracked files; 1,983 Rust files; 636,226 lines of Rust; approximately
22.7 MB of Rust source; 69.5 MB of total repository content.
* **Scope claimed.** A daemon ("drop-in replacement" for the reference daemon), embedded
firmware for three microcontroller families (including six ESP32-S3 board variants and
nRF52840), SDKs and bindings for nine languages, a browser-based node and web flasher, a
twelve-language website, a benchmark apparatus with its own publication and "proof"
pipeline, and a validation hub with oracles, fuzzing, mutation testing, and formal-proof
claims.
* **Marketing claims.** "Ground-up implementation of Reticulum"; "up to 89× the
throughput"; "48× smaller peak-memory footprint"; "33× the energy efficiency";
"Measured, not just claimed"; "Enforced, then audited"; "byte-for-byte wire parity with
the reference implementation"; "works with Sideband, NomadNet, MeshChat, etc.";
"no_std (no alloc required either)".
* **Status at the time of writing.** Version 0.3.7; published version history begins at
0.3.0. The repository continues to receive commits.
.. _brandolinis-prns-question-1:
Question 1: Is this a clean implementation, or was it directly generated from the reference?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The first of the two deciding questions from :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>` is settled by the project's own record. An actual :ref:`clean-room<brandolinis-cleanroom-delusion>` implementation, reasoned out and written by humans, would owe nothing to any license. The data available shows clearly that Prns is not that.
* **The founding state.** The first commit, "Scaffold Personal Reticulum suite", contains
the scaffolding of not one but two ports - ``personal-rns`` and ``personal-lxmf``\ , the latter
being the reference's companion messaging protocol - together with a daemon scaffold and
a 233-line founding document, ``docs/build-ethos.md``. That document declares the project's
goal as a "performance-focused drop-in-replacement for rnsd" and its governing principle
as: "Port the contract, not the implementation." It further states directly to the
machine-loop, that **"You owe the reference fidelity at exactly two boundaries:
The wire... The behavior. ... Between those two boundaries, the model is yours"**.
At this point, the very first commit, effectively the whole of the implementation design
and any relevant decisions are handed over to the LLM.
* **Continuous ingestion from the reference.** 506 commits reference RNS or Reticulum
source behaviour; the word "parity" appears in 49 commit messages. Commits cite the reference
implementation's own source locations (for example ``Transport.py:1367``) when correcting
their own divergences and mistakes.
* **Byte-level fidelity as an explicit goal.** Within 48 hours of the first commit, the
record shows a "crypto adapter - vetted primitives, byte-exact vs RNS 1.3.1", and a wire
implementation matching the reference's packet header layout. The project's own
validation apparatus decodes wire vectors using the reference implementation's own
packet parser, and the interop suite consists of real, stock-RNS peer nodes - that is,
the reference source itself, used as the ground truth against which this LLM output is
checked, and committed as accepted and verified after 48 hours of the project's recorded start.
* **The marketing mismatch.** The same record that documents all of the above describes the
project, publicly, as "a ground-up implementation of Reticulum" - while declining, on its
website, to link to the reference implementation at all: the entire tree mentions the
reference's author in six files, and the website in none.
Conclusion: the project's own history and commit record establishes that it was generated directly from the reference implementation's source code, not reasoned out from the public-domain protocol. It is a derivative of licensed work within the meaning of :ref:`the Reticulum License<brandolinis-what-the-license-is>` and :ref:`general copyright law<brandolinis-copyright-and-layers>`. The "ground-up" claim, which carries its entire legal and marketing posture, is disproven by the project's own history.
.. _brandolinis-prns-question-2:
Question 2: Who, or what, is the agent of the work?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The second deciding question is answered by the application of :ref:`Assistance Versus Machine Substitution<brandolinis-assistance-versus-substitution>` criteria to the project.
**Scope that no human could have authored**
636,226 lines of Rust in 110 days is approximately 5,800 lines per day, every day, including weekends - with 149 commits recorded between midnight and 06:00, and Saturday the single busiest weekday. No human review or decision capacity is commensurable with this volume; the review capacity and the output volume are structurally incommensurable, which is the definition of unauthored scope.
**Uniform generation**
The record shows no sign of human development, growth, or learning: No contested decisions, no style drift. Instead: endless renaming (in the first 48 hours: ``State → EngineState → TickInput → TickOutput``\ ), uniform fluent register in every commit, and the exact same, synthetic voice in code, documentation, and website copy.
**Discovery by regeneration**
Corrections arrived by the machine's own subsequent runs, recorded as planned milestones. In early July 2026, a series of "core review" commits documented, in the project's own words:
* announce-ID history "was unbounded per-slot growth" (\ ``54cc8d601``\ );
* interface announce limiting could "leak a sustained flood" (\ ``9d27af75c``\ );
* a "phantom-airtime leak" where frames "used to vanish silently" (\ ``4ed75ffdd``\ );
* Group-packet deduplication "which RNS does not do" - a behaviour the reference never had,
implemented and later removed (\ ``edd8e72be``\ );
* "both ``unwrap_or(&[])`` arms were unreachable dead defaults" (\ ``74bea355e``\ );
* a benchmark crate "hasn't compiled since" a prior rename, undetected for weeks because it
was outside the CI's workspace (\ ``86240b027``\ ).
Earlier still: the record shows a ">1 MiB RNS-to-Prns interop stall" closed three weeks in
(\ ``cc4d524a3``\ ), and a known send-path hang shipped with the note "typed fast-fail a
candidate for later" (\ ``a010e6613``\ ).
**Laundered provenance**
The repository contains a committed commit-message hook (\ ``.githooks/commit-msg``\ ) that *blocks* any commit containing attribution for machine generation ("generated with claude/codex/copilot/cursor/gemini", "co-authored-by"), with the explanation "The committer owns the commit". The contributing guide is explicit: "AI tools ... are welcome ... what you submit is *yours*", and describes the contributing population as "both human and automated contributors". The fictitious "Prns Tests" identity completes the picture: A manufactured, unknowable contributor, used for marketing content.
**Authorship by assignment**
The human whose name is on the work cannot answer for it, because the choices were never made by a human, and only the general shape and constraints of the outward presentation was. Nothing in the project's history shows an individual explaining a design decision, accepting a mistake in the first person, or going deeper under technical questioning; the record shows process language and marketing instead. Per the earlier mentioned test: any other person could have pressed the same button, and nothing would be different. The project is effectively unowned, and void of value.
By the criteria of :ref:`Assistance Versus Machine Substitution<brandolinis-assistance-versus-substitution>`, this is substitution. The machine was the agent of the work; the "author" was a facade.
.. _brandolinis-prns-performance:
The performance claims
^^^^^^^^^^^^^^^^^^^^^^
The project's central marketing claim - "up to 89× the throughput" of the reference - is also its most completely documented failure, because the project published the evidence of its own measurement. The apparatus, the results, and the problems are all on the record.
**The claim**
The README states "up to 89× the throughput"; the on-network marketing page repeats "up to 89× the throughput, 48× smaller peak-memory footprint, and 33× the energy efficiency of stock RNS 1.4.2"; the website's front page carries the tagline "Measured, not just claimed".
**The apparatus**
The reference is loaded through ``benchmarks/reference/compiled_reference.py``\ , which installs ``pyximport`` and then asserts two things: that ``RNS.compiled == True``\ , and that at least *one* RNS module was loaded from a native extension. The project's own published "proof" records show exactly what those checks captured, on every platform:
.. code-block::
aarch64-apple-darwin: .../RNS.cpython-313-darwin.so, Cython 3.2.8, Python 3.13.13
x86_64-unknown-linux-gnu: .../RNS.cpython-313-x86_64-linux-gnu.so, gcc 11.4.0
x86_64-pc-windows-msvc: ~/.prns-oc/lib.win-amd64-cpython-313/RNS.cp313-win_amd64.pyd
In every case the recorded native module is the **top-level package only** - ``RNS.so``\ , nothing below it. Nothing named ``RNS.Transport``\ , ``RNS.Destination``\ , ``RNS.Packet``\ , ``RNS.Link``\ , or ``RNS.Resource`` ever appears, because *nothing below the top level was ever compiled*. Nobody bothered to check or verify *anything* here.
The machine output was simply taken for truth, and a full marketing strategy was spun and produced on it. "RNS 1.4.2 (compiled)" - the label used in every table, chart, and marketing page - *is not a mode of RNS that exists*, but the hallucinations of a machine, which the humans created a marketing strategy on. In reality, it is the old ``CRNS`` development shim, whose top-level-only, debug-oriented "compilation" is slower than plain interpreted RNS, and which was *defunct for over a year* before these benchmarks were published.
**Interface choices**
The harness writes the reference's configuration itself (\ ``benchmarks/reference/participant_node.py``\ ): ``TCPClientInterface`` for the initiator, ``TCPServerInterface`` for the responder and both relay sides, with ``UDPInterface`` as the abstract wire. The reference was never given its modern ``BackboneInterface`` on any platform, forcing the slowest possible interrfaces. The interface selection is never mentioned in any methodology text.
**The policy**
The published default-policy tables record the asymmetry directly: Prns at 500 Mbps / 128 KiB TCP policy against the reference at 10 Mbps / 8 KiB - slyly footnoted as "preserves each implementation's normal TCP policy" (in the case of RNS, a conservative default policy that was selected to prioritize coexistence on slower, shared links, requiring the user to dial it up to full speed if they knew what they were doing). Raw transport "throughput" ratios of 20.65× (Linux) and 38.84× (Windows) are therefore mostly policy, not engine.
**The cross-host evidence**
The published results show the same scenario producing wildly different ratios by host, and the variance is entirely in the reference artifact:
.. list-table::
:header-rows: 1
* - Host
- Prns, single-packet
- "Reference", single-packet
- Ratio
* - macOS (Apple M4)
- 37.4k/s
- 420/s
- 89.09×
* - Linux (i7-1260P)
- 25.3k/s
- 3.5k/s
- 7.19×
* - Windows (Ryzen 5 5600X)
- 30.8k/s
- 3.9k/s
- 8.00×
Prns is consistent (25–37k/s). The reference artifact collapses to different depths on different hosts, and the single worst collapse - 420 packets per second on macOS - is the cell selected as the global headline. The "89×" is not a measure of Prns; it is a measure of how badly the broken baseline happened to fail on one host.
For reality calibration: Stock, interpreted RNS 1.5.4 on an ordinary mid-range laptop, single core, sustains roughly 30,000 single-packet deliveries per second (including ephemeral-key decryption), ~175,000–280,000 packets per second in transit relay, and on the order of 10 Gbps at 16 KiB payloads. The project's "compiled" artifact measured 420–3,900 packets per second for its single-packet scenario: An order of magnitude or more *below* stock interpreted RNS. The comparison being marketed was not "Rust vs Python"; **it was "an implementation running under optimal conditions versus a mislabeled, broken shim on a slow legacy interface at a severe policy disadvantage"**.
**The equalized rows**
The project's own "1 Gbps policy" rows, in which both sides are explicitly configured identically, publish ratios of roughly 2.4–8.4× across all hosts and scenarios - still against the broken baseline, but nowhere near 89×, and consistent with the ordinary, uncontroversial observation that a native implementation tends to outperform an interpreted one in raw throughput. That point needed no fudging to make, and is banal.
Interestingly, though, it seems that Prns is really only *marginally* faster than a Python implementation, running in interpreted mode, on a single CPU core.
**Assessment**
The front page says "Measured, not just claimed." The record shows the opposite ordering: claimed, and arranged to look measured. No methodology section anywhere states what "compiled" means, that it is a deprecated development shim, that it builds debug targets, or which interface the reference was given; the one statement of the policy asymmetry appears in a footnote of the results tables themselves. If they did not need to fudge it, they would have published the method clearly.
.. _brandolinis-prns-overall:
Overall Evaluation
^^^^^^^^^^^^^^^^^^
Evaluated against the conditions of :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`:
* **Provenance and attribution.** Fails: The fake "ground-up" origin story; zero reference links
on the website; a single well-hidden link in the README; a license file reading
``Copyright (c) 2026 The Prns Authors`` over work directly generated from the licensed reference;
no original copyright or permission notice anywhere.
* **Agency and answerability.** Fails on every criterion of :ref:`Assistance Versus Machine Substitution<brandolinis-assistance-versus-substitution>`:
Unauthored scope, uniform generation, discovery by regeneration, laundered provenance,
authorship by assignment.
* **Engineering.** Fails: The benchmark apparatus above; interop demonstrated only
against a pinned, outdated reference version over loopback while the marketing claims current
parity, interop failures with stock RNS; vendored prebuilt binaries and a republished fork
of an upstream crate (``nrf-softdevice 0.1.0-prns.1``) with no verifiable provenance;
committed WASM bundles.
* **Network behaviour.** Fails: Invented spectrum behaviour and compatibility claims
about third-party applications of the reference ecosystem (Sideband, NomadNet, MeshChat)
that are not established by any evidence.
* **Monetary and influence signals.** The marketing apparatus - website before protocol,
day-three twelve-language marketing, false benchmark headlines, "audited" and "formal proof"
claims - the conformal surface described in :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`:
is where this project invested.
.. _brandolinis-prns-licensing:
Licensing Analysis
^^^^^^^^^^^^^^^^^^
Applying the two legal layers established in :ref:`Copyright & The Two Legal Layers<brandolinis-copyright-and-layers>`:
**Layer A - copyright infringement (license-independent)**
The record shows a direct copy roundtrip: the licensed reference implementation fed into a machine, transformed, at a scale and cadence no human could review, with a license file asserting a fresh copyright in the operator's name and no acknowledgment of the work the project was generated from. No substantial, new human creative input is demonstrated anywhere in the record - the founding document explicitly frames the design as an instructed port of the reference's contract. A primarily machine-generated copy of a copyrighted work, not accompanied by demonstrable substantial human creative input, is a derivative work over which the copier holds no copyright, and a reproduction of which without the original author's permission infringes the original author's copyright. This holds under any license, MIT included. The operator's copyright claim over the result is, on this evidence, not merely unsubstantiated; it is the absence of one, directly asserted in the project's own writing.
**Layer B - license conditions (Reticulum License specific)**
Modern Reticulum - the current wire format, the AES-256-based link encryption, ratchets, the cryptographic machinery as it exists today - has been published under the Reticulum License since April 15, 2025, effective from release 0.9.4 and every release since. As a derivative of that work, the license's conditions attach: The copyright and permission notice must be included in all copies and substantial portions; the AI-training condition must be honoured; the harm condition must be honoured. The record shows none of the notice requirements met, and a production process that consists of the licensed work being ingested into a machine and regurgitated, at industrial scale and cadence.
**The cascading consequence**
Prns is distributed claiming dual MIT/Apache-2.0 licensing. It is, however, a direct derivative of Reticulum-licensed work, and the claimed grant is therefore void. Every downstream project that builds on Prns believing it is MIT/Apache-licensed is building on a grant that does not exist. The users of Prns, and all software developers using it, have in effect, been placed under conditions they were never told about. The "ground-up" claim is not merely false; it is the sole load-bearing element of an entire licensing posture, and it fails spectacularly.
.. _brandolinis-prns-consequences:
Consequences
^^^^^^^^^^^^
The consequences of this pattern are examined in the following sections - the harm to users and to the network in :ref:`A Movement Of A Dozen<brandolinis-movement-of-a-dozen>`, and the human dimension in :ref:`Network Health & Coexistence<brandolinis-health-and-coexistence>`. This section's contribution is narrower and intended as an instructive example: This is what a substitution project looks like, in full, on its own record. It is a reference example for :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`, and it demonstrates, in one case, most of the elements this chapter describes.
.. _brandolinis-prns-verdict:
Verdict
^^^^^^^
Applying the three verdicts of :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`, this project does not meet the standard. It is not "experimental but honest" - it is not labeled as experimental anywhere; the first thing users saw was a polished marketing presence promising a finished, tested, drop-in replacement. It is a project whose central claims are fabricated (the performance apparatus), whose provenance is laundered (the authorship machinery), whose foundation is misrepresented (the "ground-up" story), whose core semantics were learned late and by regeneration, and whose operator cannot possibly answer for any of it. It is also a blatant copyright violation of the reference implementation.
The proposed conclusion, for users and for the network: Treat the Prns project as hostile regardless of its polished surface, and as a hazard insofar as it invites users onto shared networks. Nothing in this section is a judgment about the people involved; it is a reading of the results produced, their history and how they came to be, which in the regrettable lack of any human authorship is the only thing that can be expected to be held to account.
.. _brandolinis-prns-dating:
Dating
^^^^^^
This examination reflects the publicly available material as of September 2026; the repository in question continued to receive commits at the time of writing, so readers should treat citations to commits and files as point-in-time evidence. A `forensics snapshot <https://github.com/markqvist/forensics_prns>`_ is publicly available on GitHub.
.. _brandolinis-movement-of-a-dozen:
The Movement Of A Dozen
@ -1322,4 +1065,261 @@ A lot of us rely on these networks every day. They carry our messages, our coord
They are valuable, free, and very hard to shut down. The response is not to become aggressive. It is to be *more* of what the network already is: Real, open, owned, and shared.
*Mark*
*Mark*
.. _brandolinis-prns:
Addendum A: The Prns Case
-------------------------
.. _brandolinis-purpose-and-scope:
Purpose & Scope
^^^^^^^^^^^^^^^
This section provides a concrete example, which future evaluations can use as a template. Its purpose is not to be the last word on this particular subject, but to be an example of how the ideas in this chapter can be applied, and to make the next such examination easier.
The subject of this case study is **Prns**\ , a project published at the repository ``github.com/KenAKAFrosty/Prns``\ , presented as a "ground-up implementation of Reticulum, written in Rust", marketed as faster, safer, and more strictly tested than the reference, and widely promoted with the claim of "up to 89× the throughput" of the reference implementation. The record described below is the project's own, and sourced from its GitHub repository, analyzed locally.
.. _brandolinis-project-in-brief:
The Project In Brief
^^^^^^^^^^^^^^^^^^^^
* **Time span.** 3,374 commits between 2026-05-26 and 2026-09-12: approximately 110 days,
at a mean rate of ~31 commits per day. Monthly: 132 / 1,137 / 1,097 / 805 / 203.
* **Authorship.** 3,252 of 3,374 commits (96.4%) are authored by a single account. A
second identity, "Prns Tests tests@example.test" - a fictitious identity on a reserved
domain - contributed 35 commits, every one of them website and marketing content.
* **Size.** 3,519 tracked files; 1,983 Rust files; 636,226 lines of Rust; approximately
22.7 MB of Rust source; 69.5 MB of total repository content.
* **Scope claimed.** A daemon ("drop-in replacement" for the reference daemon), embedded
firmware for three microcontroller families (including six ESP32-S3 board variants and
nRF52840), SDKs and bindings for nine languages, a browser-based node and web flasher, a
twelve-language website, a benchmark apparatus with its own publication and "proof"
pipeline, and a validation hub with oracles, fuzzing, mutation testing, and formal-proof
claims.
* **Marketing claims.** "Ground-up implementation of Reticulum"; "up to 89× the
throughput"; "48× smaller peak-memory footprint"; "33× the energy efficiency";
"Measured, not just claimed"; "Enforced, then audited"; "byte-for-byte wire parity with
the reference implementation"; "works with Sideband, NomadNet, MeshChat, etc.";
"no_std (no alloc required either)".
* **Status at the time of writing.** Version 0.3.7; published version history begins at
0.3.0. The repository continues to receive commits.
.. _brandolinis-prns-question-1:
Question 1: Is this a clean implementation, or was it directly generated from the reference?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The first of the two deciding questions from :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>` is settled by the project's own record. An actual :ref:`clean-room<brandolinis-cleanroom-delusion>` implementation, reasoned out and written by humans, would owe nothing to any license. The data available shows clearly that Prns is not that.
* **The founding state.** The first commit, "Scaffold Personal Reticulum suite", contains
the scaffolding of not one but two ports - ``personal-rns`` and ``personal-lxmf``\ , the latter
being the reference's companion messaging protocol - together with a daemon scaffold and
a 233-line founding document, ``docs/build-ethos.md``. That document declares the project's
goal as a "performance-focused drop-in-replacement for rnsd" and its governing principle
as: "Port the contract, not the implementation." It further states directly to the
machine-loop, that **"You owe the reference fidelity at exactly two boundaries:
The wire... The behavior. ... Between those two boundaries, the model is yours"**.
At this point, the very first commit, effectively the whole of the implementation design
and any relevant decisions are handed over to the LLM.
* **Continuous ingestion from the reference.** 506 commits reference RNS or Reticulum
source behaviour; the word "parity" appears in 49 commit messages. Commits cite the reference
implementation's own source locations (for example ``Transport.py:1367``) when correcting
their own divergences and mistakes.
* **Byte-level fidelity as an explicit goal.** Within 48 hours of the first commit, the
record shows a "crypto adapter - vetted primitives, byte-exact vs RNS 1.3.1", and a wire
implementation matching the reference's packet header layout. The project's own
validation apparatus decodes wire vectors using the reference implementation's own
packet parser, and the interop suite consists of real, stock-RNS peer nodes - that is,
the reference source itself, used as the ground truth against which this LLM output is
checked, and committed as accepted and verified after 48 hours of the project's recorded start.
* **The marketing mismatch.** The same record that documents all of the above describes the
project, publicly, as "a ground-up implementation of Reticulum" - while declining, on its
website, to link to the reference implementation at all: the entire tree mentions the
reference's author in six files, and the website in none.
Conclusion: the project's own history and commit record establishes that it was generated directly from the reference implementation's source code, not reasoned out from the public-domain protocol. It is a derivative of licensed work within the meaning of :ref:`the Reticulum License<brandolinis-what-the-license-is>` and :ref:`general copyright law<brandolinis-copyright-and-layers>`. The "ground-up" claim, which carries its entire legal and marketing posture, is disproven by the project's own history.
.. _brandolinis-prns-question-2:
Question 2: Who, or what, is the agent of the work?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The second deciding question is answered by the application of :ref:`Assistance Versus Machine Substitution<brandolinis-assistance-versus-substitution>` criteria to the project.
**Scope that no human could have authored**
636,226 lines of Rust in 110 days is approximately 5,800 lines per day, every day, including weekends - with 149 commits recorded between midnight and 06:00, and Saturday the single busiest weekday. No human review or decision capacity is commensurable with this volume; the review capacity and the output volume are structurally incommensurable, which is the definition of unauthored scope.
**Uniform generation**
The record shows no sign of human development, growth, or learning: No contested decisions, no style drift. Instead: endless renaming (in the first 48 hours: ``State → EngineState → TickInput → TickOutput``\ ), uniform fluent register in every commit, and the exact same, synthetic voice in code, documentation, and website copy.
**Discovery by regeneration**
Corrections arrived by the machine's own subsequent runs, recorded as planned milestones. In early July 2026, a series of "core review" commits documented, in the project's own words:
* announce-ID history "was unbounded per-slot growth" (\ ``54cc8d601``\ );
* interface announce limiting could "leak a sustained flood" (\ ``9d27af75c``\ );
* a "phantom-airtime leak" where frames "used to vanish silently" (\ ``4ed75ffdd``\ );
* Group-packet deduplication "which RNS does not do" - a behaviour the reference never had,
implemented and later removed (\ ``edd8e72be``\ );
* "both ``unwrap_or(&[])`` arms were unreachable dead defaults" (\ ``74bea355e``\ );
* a benchmark crate "hasn't compiled since" a prior rename, undetected for weeks because it
was outside the CI's workspace (\ ``86240b027``\ ).
Earlier still: the record shows a ">1 MiB RNS-to-Prns interop stall" closed three weeks in
(\ ``cc4d524a3``\ ), and a known send-path hang shipped with the note "typed fast-fail a
candidate for later" (\ ``a010e6613``\ ).
**Laundered provenance**
The repository contains a committed commit-message hook (\ ``.githooks/commit-msg``\ ) that *blocks* any commit containing attribution for machine generation ("generated with claude/codex/copilot/cursor/gemini", "co-authored-by"), with the explanation "The committer owns the commit". The contributing guide is explicit: "AI tools ... are welcome ... what you submit is *yours*", and describes the contributing population as "both human and automated contributors". The fictitious "Prns Tests" identity completes the picture: A manufactured, unknowable contributor, used for marketing content.
**Authorship by assignment**
The human whose name is on the work cannot answer for it, because the choices were never made by a human, and only the general shape and constraints of the outward presentation was. Nothing in the project's history shows an individual explaining a design decision, accepting a mistake in the first person, or going deeper under technical questioning; the record shows process language and marketing instead. Per the earlier mentioned test: any other person could have pressed the same button, and nothing would be different. The project is effectively unowned, and void of value.
By the criteria of :ref:`Assistance Versus Machine Substitution<brandolinis-assistance-versus-substitution>`, this is substitution. The machine was the agent of the work; the "author" was a facade.
.. _brandolinis-prns-performance:
The performance claims
^^^^^^^^^^^^^^^^^^^^^^
The project's central marketing claim - "up to 89× the throughput" of the reference - is also its most completely documented failure, because the project published the evidence of its own measurement. The apparatus, the results, and the problems are all on the record.
**The claim**
The README states "up to 89× the throughput"; the on-network marketing page repeats "up to 89× the throughput, 48× smaller peak-memory footprint, and 33× the energy efficiency of stock RNS 1.4.2"; the website's front page carries the tagline "Measured, not just claimed".
**The apparatus**
The reference is loaded through ``benchmarks/reference/compiled_reference.py``\ , which installs ``pyximport`` and then asserts two things: that ``RNS.compiled == True``\ , and that at least *one* RNS module was loaded from a native extension. The project's own published "proof" records show exactly what those checks captured, on every platform:
.. code-block::
aarch64-apple-darwin: .../RNS.cpython-313-darwin.so, Cython 3.2.8, Python 3.13.13
x86_64-unknown-linux-gnu: .../RNS.cpython-313-x86_64-linux-gnu.so, gcc 11.4.0
x86_64-pc-windows-msvc: ~/.prns-oc/lib.win-amd64-cpython-313/RNS.cp313-win_amd64.pyd
In every case the recorded native module is the **top-level package only** - ``RNS.so``\ , nothing below it. Nothing named ``RNS.Transport``\ , ``RNS.Destination``\ , ``RNS.Packet``\ , ``RNS.Link``\ , or ``RNS.Resource`` ever appears, because *nothing below the top level was ever compiled*. Nobody bothered to check or verify *anything* here.
The machine output was simply taken for truth, and a full marketing strategy was spun and produced on it. "RNS 1.4.2 (compiled)" - the label used in every table, chart, and marketing page - *is not a mode of RNS that exists*, but the hallucinations of a machine, which the humans created a marketing strategy on. In reality, it is the old ``CRNS`` development shim, whose top-level-only, debug-oriented "compilation" is slower than plain interpreted RNS, and which was *defunct for over a year* before these benchmarks were published.
**Interface choices**
The harness writes the reference's configuration itself (\ ``benchmarks/reference/participant_node.py``\ ): ``TCPClientInterface`` for the initiator, ``TCPServerInterface`` for the responder and both relay sides, with ``UDPInterface`` as the abstract wire. The reference was never given its modern ``BackboneInterface`` on any platform, forcing the slowest possible interrfaces. The interface selection is never mentioned in any methodology text.
**The policy**
The published default-policy tables record the asymmetry directly: Prns at 500 Mbps / 128 KiB TCP policy against the reference at 10 Mbps / 8 KiB - slyly footnoted as "preserves each implementation's normal TCP policy" (in the case of RNS, a conservative default policy that was selected to prioritize coexistence on slower, shared links, requiring the user to dial it up to full speed if they knew what they were doing). Raw transport "throughput" ratios of 20.65× (Linux) and 38.84× (Windows) are therefore mostly policy, not engine.
**The cross-host evidence**
The published results show the same scenario producing wildly different ratios by host, and the variance is entirely in the reference artifact:
.. list-table::
:header-rows: 1
* - Host
- Prns, single-packet
- "Reference", single-packet
- Ratio
* - macOS (Apple M4)
- 37.4k/s
- 420/s
- 89.09×
* - Linux (i7-1260P)
- 25.3k/s
- 3.5k/s
- 7.19×
* - Windows (Ryzen 5 5600X)
- 30.8k/s
- 3.9k/s
- 8.00×
Prns is consistent (25–37k/s). The reference artifact collapses to different depths on different hosts, and the single worst collapse - 420 packets per second on macOS - is the cell selected as the global headline. The "89×" is not a measure of Prns; it is a measure of how badly the broken baseline happened to fail on one host.
For reality calibration: Stock, interpreted RNS 1.5.4 on an ordinary mid-range laptop, single core, sustains roughly 30,000 single-packet deliveries per second (including ephemeral-key decryption), ~175,000–280,000 packets per second in transit relay, and on the order of 10 Gbps at 16 KiB payloads. The project's "compiled" artifact measured 420–3,900 packets per second for its single-packet scenario: An order of magnitude or more *below* stock interpreted RNS. The comparison being marketed was not "Rust vs Python"; **it was "an implementation running under optimal conditions versus a mislabeled, broken shim on a slow legacy interface at a severe policy disadvantage"**.
**The equalized rows**
The project's own "1 Gbps policy" rows, in which both sides are explicitly configured identically, publish ratios of roughly 2.4–8.4× across all hosts and scenarios - still against the broken baseline, but nowhere near 89×, and consistent with the ordinary, uncontroversial observation that a native implementation tends to outperform an interpreted one in raw throughput. That point needed no fudging to make, and is banal.
Interestingly, though, it seems that Prns is really only *marginally* faster than a Python implementation, running in interpreted mode, on a single CPU core.
**Assessment**
The front page says "Measured, not just claimed." The record shows the opposite ordering: claimed, and arranged to look measured. No methodology section anywhere states what "compiled" means, that it is a deprecated development shim, that it builds debug targets, or which interface the reference was given; the one statement of the policy asymmetry appears in a footnote of the results tables themselves. If they did not need to fudge it, they would have published the method clearly.
.. _brandolinis-prns-overall:
Overall Evaluation
^^^^^^^^^^^^^^^^^^
Evaluated against the conditions of :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`:
* **Provenance and attribution.** Fails: The fake "ground-up" origin story; zero reference links
on the website; a single well-hidden link in the README; a license file reading
``Copyright (c) 2026 The Prns Authors`` over work directly generated from the licensed reference;
no original copyright or permission notice anywhere.
* **Agency and answerability.** Fails on every criterion of :ref:`Assistance Versus Machine Substitution<brandolinis-assistance-versus-substitution>`:
Unauthored scope, uniform generation, discovery by regeneration, laundered provenance,
authorship by assignment.
* **Engineering.** Fails: The benchmark apparatus above; interop demonstrated only
against a pinned, outdated reference version over loopback while the marketing claims current
parity, interop failures with stock RNS; vendored prebuilt binaries and a republished fork
of an upstream crate (``nrf-softdevice 0.1.0-prns.1``) with no verifiable provenance;
committed WASM bundles.
* **Network behaviour.** Fails: Invented spectrum behaviour and compatibility claims
about third-party applications of the reference ecosystem (Sideband, NomadNet, MeshChat)
that are not established by any evidence.
* **Monetary and influence signals.** The marketing apparatus - website before protocol,
day-three twelve-language marketing, false benchmark headlines, "audited" and "formal proof"
claims - the conformal surface described in :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`:
is where this project invested.
.. _brandolinis-prns-licensing:
Licensing Analysis
^^^^^^^^^^^^^^^^^^
Applying the two legal layers established in :ref:`Copyright & The Two Legal Layers<brandolinis-copyright-and-layers>`:
**Layer A - copyright infringement (license-independent)**
The record shows a direct copy roundtrip: the licensed reference implementation fed into a machine, transformed, at a scale and cadence no human could review, with a license file asserting a fresh copyright in the operator's name and no acknowledgment of the work the project was generated from. No substantial, new human creative input is demonstrated anywhere in the record - the founding document explicitly frames the design as an instructed port of the reference's contract. A primarily machine-generated copy of a copyrighted work, not accompanied by demonstrable substantial human creative input, is a derivative work over which the copier holds no copyright, and a reproduction of which without the original author's permission infringes the original author's copyright. This holds under any license, MIT included. The operator's copyright claim over the result is, on this evidence, not merely unsubstantiated; it is the absence of one, directly asserted in the project's own writing.
**Layer B - license conditions (Reticulum License specific)**
Modern Reticulum - the current wire format, the AES-256-based link encryption, ratchets, the cryptographic machinery as it exists today - has been published under the Reticulum License since April 15, 2025, effective from release 0.9.4 and every release since. As a derivative of that work, the license's conditions attach: The copyright and permission notice must be included in all copies and substantial portions; the AI-training condition must be honoured; the harm condition must be honoured. The record shows none of the notice requirements met, and a production process that consists of the licensed work being ingested into a machine and regurgitated, at industrial scale and cadence.
**The cascading consequence**
Prns is distributed claiming dual MIT/Apache-2.0 licensing. It is, however, a direct derivative of Reticulum-licensed work, and the claimed grant is therefore void. Every downstream project that builds on Prns believing it is MIT/Apache-licensed is building on a grant that does not exist. The users of Prns, and all software developers using it, have in effect, been placed under conditions they were never told about. The "ground-up" claim is not merely false; it is the sole load-bearing element of an entire licensing posture, and it fails spectacularly.
.. _brandolinis-prns-consequences:
Consequences
^^^^^^^^^^^^
The consequences of this pattern are examined in the following sections: The harm to users and to the network in :ref:`A Movement Of A Dozen<brandolinis-movement-of-a-dozen>`, and the human dimension in :ref:`Network Health & Coexistence<brandolinis-health-and-coexistence>`. The contribution of this addendum is narrower and intended as an instructive example: This is what a substitution project looks like, in full, on its own record. It is a reference example for :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`, and it demonstrates, in one case, most of the elements this chapter describes.
.. _brandolinis-prns-verdict:
Verdict
^^^^^^^
Applying the three verdicts of :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`, this project does not meet the standard. It is not "experimental but honest" - it is not labeled as experimental anywhere; the first thing users saw was a polished marketing presence promising a finished, tested, drop-in replacement. It is a project whose central claims are fabricated (the performance apparatus), whose provenance is laundered (the authorship machinery), whose foundation is misrepresented (the "ground-up" story), whose core semantics were learned late and by regeneration, and whose operator cannot possibly answer for any of it. It is also a blatant copyright violation of the reference implementation.
The proposed conclusion, for users and for the network: Treat the Prns project as hostile regardless of its polished surface, and as a hazard insofar as it invites users onto shared networks. Nothing in this section is a judgment about the people involved; it is a reading of the results produced, their history and how they came to be, which in the regrettable lack of any human authorship is the only thing that can be expected to be held to account.
.. _brandolinis-prns-dating:
Dating
^^^^^^
This examination reflects the publicly available material as of September 2026; the repository in question continued to receive commits at the time of writing, so readers should treat citations to commits and files as point-in-time evidence. A `forensics snapshot <https://github.com/markqvist/forensics_prns>`_ is publicly available on GitHub.

420
docs/manual/brandolinis.html
View file

@ -791,203 +791,6 @@ time is better spent elsewhere.</p></li>
<p>The reference implementation has met this standard for years, and its users know what that looks like.</p>
</section>
</section>
<section id="the-prns-case">
<span id="brandolinis-prns"></span><h2>The Prns Case<a class="headerlink" href="#the-prns-case" title="Link to this heading"></a></h2>
<section id="purpose-scope">
<span id="brandolinis-purpose-and-scope"></span><h3>Purpose &amp; Scope<a class="headerlink" href="#purpose-scope" title="Link to this heading"></a></h3>
<p>This section provides a concrete example, which future evaluations can use as a template. Its purpose is not to be the last word on this particular subject, but to be an example of how the ideas in this chapter can be applied, and to make the next such examination easier.</p>
<p>The subject of this case study is <strong>Prns</strong>, a project published at the repository <code class="docutils literal notranslate"><span class="pre">github.com/KenAKAFrosty/Prns</span></code>, presented as a “ground-up implementation of Reticulum, written in Rust”, marketed as faster, safer, and more strictly tested than the reference, and widely promoted with the claim of “up to 89× the throughput” of the reference implementation. The record described below is the project’s own, and sourced from its GitHub repository, analyzed locally.</p>
</section>
<section id="the-project-in-brief">
<span id="brandolinis-project-in-brief"></span><h3>The Project In Brief<a class="headerlink" href="#the-project-in-brief" title="Link to this heading"></a></h3>
<ul class="simple">
<li><p><strong>Time span.</strong> 3,374 commits between 2026-05-26 and 2026-09-12: approximately 110 days,
at a mean rate of ~31 commits per day. Monthly: 132 / 1,137 / 1,097 / 805 / 203.</p></li>
<li><p><strong>Authorship.</strong> 3,252 of 3,374 commits (96.4%) are authored by a single account. A
second identity, “Prns Tests <a class="reference external" href="mailto:tests&#37;&#52;&#48;example&#46;test">tests<span>&#64;</span>example<span>&#46;</span>test</a>” - a fictitious identity on a reserved
domain - contributed 35 commits, every one of them website and marketing content.</p></li>
<li><p><strong>Size.</strong> 3,519 tracked files; 1,983 Rust files; 636,226 lines of Rust; approximately
22.7 MB of Rust source; 69.5 MB of total repository content.</p></li>
<li><p><strong>Scope claimed.</strong> A daemon (“drop-in replacement” for the reference daemon), embedded
firmware for three microcontroller families (including six ESP32-S3 board variants and
nRF52840), SDKs and bindings for nine languages, a browser-based node and web flasher, a
twelve-language website, a benchmark apparatus with its own publication and “proof”
pipeline, and a validation hub with oracles, fuzzing, mutation testing, and formal-proof
claims.</p></li>
<li><p><strong>Marketing claims.</strong> “Ground-up implementation of Reticulum”; “up to 89× the
throughput”; “48× smaller peak-memory footprint”; “33× the energy efficiency”;
“Measured, not just claimed”; “Enforced, then audited”; “byte-for-byte wire parity with
the reference implementation”; “works with Sideband, NomadNet, MeshChat, etc.”;
“no_std (no alloc required either)”.</p></li>
<li><p><strong>Status at the time of writing.</strong> Version 0.3.7; published version history begins at
0.3.0. The repository continues to receive commits.</p></li>
</ul>
</section>
<section id="question-1-is-this-a-clean-implementation-or-was-it-directly-generated-from-the-reference">
<span id="brandolinis-prns-question-1"></span><h3>Question 1: Is this a clean implementation, or was it directly generated from the reference?<a class="headerlink" href="#question-1-is-this-a-clean-implementation-or-was-it-directly-generated-from-the-reference" title="Link to this heading"></a></h3>
<p>The first of the two deciding questions from <a class="reference internal" href="#brandolinis-evaluating"><span class="std std-ref">Evaluating A Reticulum Implementation</span></a> is settled by the project’s own record. An actual <a class="reference internal" href="#brandolinis-cleanroom-delusion"><span class="std std-ref">clean-room</span></a> implementation, reasoned out and written by humans, would owe nothing to any license. The data available shows clearly that Prns is not that.</p>
<ul class="simple">
<li><p><strong>The founding state.</strong> The first commit, “Scaffold Personal Reticulum suite”, contains
the scaffolding of not one but two ports - <code class="docutils literal notranslate"><span class="pre">personal-rns</span></code> and <code class="docutils literal notranslate"><span class="pre">personal-lxmf</span></code>, the latter
being the reference’s companion messaging protocol - together with a daemon scaffold and
a 233-line founding document, <code class="docutils literal notranslate"><span class="pre">docs/build-ethos.md</span></code>. That document declares the project’s
goal as a “performance-focused drop-in-replacement for rnsd” and its governing principle
as: “Port the contract, not the implementation.” It further states directly to the
machine-loop, that <strong>“You owe the reference fidelity at exactly two boundaries:
The wire… The behavior. … Between those two boundaries, the model is yours”</strong>.
At this point, the very first commit, effectively the whole of the implementation design
and any relevant decisions are handed over to the LLM.</p></li>
<li><p><strong>Continuous ingestion from the reference.</strong> 506 commits reference RNS or Reticulum
source behaviour; the word “parity” appears in 49 commit messages. Commits cite the reference
implementation’s own source locations (for example <code class="docutils literal notranslate"><span class="pre">Transport.py:1367</span></code>) when correcting
their own divergences and mistakes.</p></li>
<li><p><strong>Byte-level fidelity as an explicit goal.</strong> Within 48 hours of the first commit, the
record shows a “crypto adapter - vetted primitives, byte-exact vs RNS 1.3.1”, and a wire
implementation matching the reference’s packet header layout. The project’s own
validation apparatus decodes wire vectors using the reference implementation’s own
packet parser, and the interop suite consists of real, stock-RNS peer nodes - that is,
the reference source itself, used as the ground truth against which this LLM output is
checked, and committed as accepted and verified after 48 hours of the project’s recorded start.</p></li>
<li><p><strong>The marketing mismatch.</strong> The same record that documents all of the above describes the
project, publicly, as “a ground-up implementation of Reticulum” - while declining, on its
website, to link to the reference implementation at all: the entire tree mentions the
reference’s author in six files, and the website in none.</p></li>
</ul>
<p>Conclusion: the project’s own history and commit record establishes that it was generated directly from the reference implementation’s source code, not reasoned out from the public-domain protocol. It is a derivative of licensed work within the meaning of <a class="reference internal" href="#brandolinis-what-the-license-is"><span class="std std-ref">the Reticulum License</span></a> and <a class="reference internal" href="#brandolinis-copyright-and-layers"><span class="std std-ref">general copyright law</span></a>. The “ground-up” claim, which carries its entire legal and marketing posture, is disproven by the project’s own history.</p>
</section>
<section id="question-2-who-or-what-is-the-agent-of-the-work">
<span id="brandolinis-prns-question-2"></span><h3>Question 2: Who, or what, is the agent of the work?<a class="headerlink" href="#question-2-who-or-what-is-the-agent-of-the-work" title="Link to this heading"></a></h3>
<p>The second deciding question is answered by the application of <a class="reference internal" href="#brandolinis-assistance-versus-substitution"><span class="std std-ref">Assistance Versus Machine Substitution</span></a> criteria to the project.</p>
<p><strong>Scope that no human could have authored</strong></p>
<p>636,226 lines of Rust in 110 days is approximately 5,800 lines per day, every day, including weekends - with 149 commits recorded between midnight and 06:00, and Saturday the single busiest weekday. No human review or decision capacity is commensurable with this volume; the review capacity and the output volume are structurally incommensurable, which is the definition of unauthored scope.</p>
<p><strong>Uniform generation</strong></p>
<p>The record shows no sign of human development, growth, or learning: No contested decisions, no style drift. Instead: endless renaming (in the first 48 hours: <code class="docutils literal notranslate"><span class="pre">State</span> <span class="pre">→</span> <span class="pre">EngineState</span> <span class="pre">→</span> <span class="pre">TickInput</span> <span class="pre">→</span> <span class="pre">TickOutput</span></code>), uniform fluent register in every commit, and the exact same, synthetic voice in code, documentation, and website copy.</p>
<p><strong>Discovery by regeneration</strong></p>
<p>Corrections arrived by the machine’s own subsequent runs, recorded as planned milestones. In early July 2026, a series of “core review” commits documented, in the project’s own words:</p>
<ul class="simple">
<li><p>announce-ID history “was unbounded per-slot growth” (<code class="docutils literal notranslate"><span class="pre">54cc8d601</span></code>);</p></li>
<li><p>interface announce limiting could “leak a sustained flood” (<code class="docutils literal notranslate"><span class="pre">9d27af75c</span></code>);</p></li>
<li><p>a “phantom-airtime leak” where frames “used to vanish silently” (<code class="docutils literal notranslate"><span class="pre">4ed75ffdd</span></code>);</p></li>
<li><p>Group-packet deduplication “which RNS does not do” - a behaviour the reference never had,
implemented and later removed (<code class="docutils literal notranslate"><span class="pre">edd8e72be</span></code>);</p></li>
<li><p>“both <code class="docutils literal notranslate"><span class="pre">unwrap_or(&amp;[])</span></code> arms were unreachable dead defaults” (<code class="docutils literal notranslate"><span class="pre">74bea355e</span></code>);</p></li>
<li><p>a benchmark crate “hasn’t compiled since” a prior rename, undetected for weeks because it
was outside the CI’s workspace (<code class="docutils literal notranslate"><span class="pre">86240b027</span></code>).</p></li>
</ul>
<p>Earlier still: the record shows a “&gt;1 MiB RNS-to-Prns interop stall” closed three weeks in
(<code class="docutils literal notranslate"><span class="pre">cc4d524a3</span></code>), and a known send-path hang shipped with the note “typed fast-fail a
candidate for later” (<code class="docutils literal notranslate"><span class="pre">a010e6613</span></code>).</p>
<p><strong>Laundered provenance</strong></p>
<p>The repository contains a committed commit-message hook (<code class="docutils literal notranslate"><span class="pre">.githooks/commit-msg</span></code>) that <em>blocks</em> any commit containing attribution for machine generation (“generated with claude/codex/copilot/cursor/gemini”, “co-authored-by”), with the explanation “The committer owns the commit”. The contributing guide is explicit: “AI tools … are welcome … what you submit is <em>yours</em>”, and describes the contributing population as “both human and automated contributors”. The fictitious “Prns Tests” identity completes the picture: A manufactured, unknowable contributor, used for marketing content.</p>
<p><strong>Authorship by assignment</strong></p>
<p>The human whose name is on the work cannot answer for it, because the choices were never made by a human, and only the general shape and constraints of the outward presentation was. Nothing in the project’s history shows an individual explaining a design decision, accepting a mistake in the first person, or going deeper under technical questioning; the record shows process language and marketing instead. Per the earlier mentioned test: any other person could have pressed the same button, and nothing would be different. The project is effectively unowned, and void of value.</p>
<p>By the criteria of <a class="reference internal" href="#brandolinis-assistance-versus-substitution"><span class="std std-ref">Assistance Versus Machine Substitution</span></a>, this is substitution. The machine was the agent of the work; the “author” was a facade.</p>
</section>
<section id="the-performance-claims">
<span id="brandolinis-prns-performance"></span><h3>The performance claims<a class="headerlink" href="#the-performance-claims" title="Link to this heading"></a></h3>
<p>The project’s central marketing claim - “up to 89× the throughput” of the reference - is also its most completely documented failure, because the project published the evidence of its own measurement. The apparatus, the results, and the problems are all on the record.</p>
<p><strong>The claim</strong></p>
<p>The README states “up to 89× the throughput”; the on-network marketing page repeats “up to 89× the throughput, 48× smaller peak-memory footprint, and 33× the energy efficiency of stock RNS 1.4.2”; the website’s front page carries the tagline “Measured, not just claimed”.</p>
<p><strong>The apparatus</strong></p>
<p>The reference is loaded through <code class="docutils literal notranslate"><span class="pre">benchmarks/reference/compiled_reference.py</span></code>, which installs <code class="docutils literal notranslate"><span class="pre">pyximport</span></code> and then asserts two things: that <code class="docutils literal notranslate"><span class="pre">RNS.compiled</span> <span class="pre">==</span> <span class="pre">True</span></code>, and that at least <em>one</em> RNS module was loaded from a native extension. The project’s own published “proof” records show exactly what those checks captured, on every platform:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">aarch64</span><span class="o">-</span><span class="n">apple</span><span class="o">-</span><span class="n">darwin</span><span class="p">:</span> <span class="o">.../</span><span class="n">RNS</span><span class="o">.</span><span class="n">cpython</span><span class="o">-</span><span class="mi">313</span><span class="o">-</span><span class="n">darwin</span><span class="o">.</span><span class="n">so</span><span class="p">,</span> <span class="n">Cython</span> <span class="mf">3.2.8</span><span class="p">,</span> <span class="n">Python</span> <span class="mf">3.13.13</span>
<span class="n">x86_64</span><span class="o">-</span><span class="n">unknown</span><span class="o">-</span><span class="n">linux</span><span class="o">-</span><span class="n">gnu</span><span class="p">:</span> <span class="o">.../</span><span class="n">RNS</span><span class="o">.</span><span class="n">cpython</span><span class="o">-</span><span class="mi">313</span><span class="o">-</span><span class="n">x86_64</span><span class="o">-</span><span class="n">linux</span><span class="o">-</span><span class="n">gnu</span><span class="o">.</span><span class="n">so</span><span class="p">,</span> <span class="n">gcc</span> <span class="mf">11.4.0</span>
<span class="n">x86_64</span><span class="o">-</span><span class="n">pc</span><span class="o">-</span><span class="n">windows</span><span class="o">-</span><span class="n">msvc</span><span class="p">:</span> <span class="o">~/.</span><span class="n">prns</span><span class="o">-</span><span class="n">oc</span><span class="o">/</span><span class="n">lib</span><span class="o">.</span><span class="n">win</span><span class="o">-</span><span class="n">amd64</span><span class="o">-</span><span class="n">cpython</span><span class="o">-</span><span class="mi">313</span><span class="o">/</span><span class="n">RNS</span><span class="o">.</span><span class="n">cp313</span><span class="o">-</span><span class="n">win_amd64</span><span class="o">.</span><span class="n">pyd</span>
</pre></div>
</div>
<p>In every case the recorded native module is the <strong>top-level package only</strong> - <code class="docutils literal notranslate"><span class="pre">RNS.so</span></code>, nothing below it. Nothing named <code class="docutils literal notranslate"><span class="pre">RNS.Transport</span></code>, <code class="docutils literal notranslate"><span class="pre">RNS.Destination</span></code>, <code class="docutils literal notranslate"><span class="pre">RNS.Packet</span></code>, <code class="docutils literal notranslate"><span class="pre">RNS.Link</span></code>, or <code class="docutils literal notranslate"><span class="pre">RNS.Resource</span></code> ever appears, because <em>nothing below the top level was ever compiled</em>. Nobody bothered to check or verify <em>anything</em> here.</p>
<p>The machine output was simply taken for truth, and a full marketing strategy was spun and produced on it. “RNS 1.4.2 (compiled)” - the label used in every table, chart, and marketing page - <em>is not a mode of RNS that exists</em>, but the hallucinations of a machine, which the humans created a marketing strategy on. In reality, it is the old <code class="docutils literal notranslate"><span class="pre">CRNS</span></code> development shim, whose top-level-only, debug-oriented “compilation” is slower than plain interpreted RNS, and which was <em>defunct for over a year</em> before these benchmarks were published.</p>
<p><strong>Interface choices</strong></p>
<p>The harness writes the reference’s configuration itself (<code class="docutils literal notranslate"><span class="pre">benchmarks/reference/participant_node.py</span></code>): <code class="docutils literal notranslate"><span class="pre">TCPClientInterface</span></code> for the initiator, <code class="docutils literal notranslate"><span class="pre">TCPServerInterface</span></code> for the responder and both relay sides, with <code class="docutils literal notranslate"><span class="pre">UDPInterface</span></code> as the abstract wire. The reference was never given its modern <code class="docutils literal notranslate"><span class="pre">BackboneInterface</span></code> on any platform, forcing the slowest possible interrfaces. The interface selection is never mentioned in any methodology text.</p>
<p><strong>The policy</strong></p>
<p>The published default-policy tables record the asymmetry directly: Prns at 500 Mbps / 128 KiB TCP policy against the reference at 10 Mbps / 8 KiB - slyly footnoted as “preserves each implementation’s normal TCP policy” (in the case of RNS, a conservative default policy that was selected to prioritize coexistence on slower, shared links, requiring the user to dial it up to full speed if they knew what they were doing). Raw transport “throughput” ratios of 20.65× (Linux) and 38.84× (Windows) are therefore mostly policy, not engine.</p>
<p><strong>The cross-host evidence</strong></p>
<p>The published results show the same scenario producing wildly different ratios by host, and the variance is entirely in the reference artifact:</p>
<div class="table-wrapper docutils container">
<table class="docutils align-default">
<thead>
<tr class="row-odd"><th class="head"><p>Host</p></th>
<th class="head"><p>Prns, single-packet</p></th>
<th class="head"><p>“Reference”, single-packet</p></th>
<th class="head"><p>Ratio</p></th>
</tr>
</thead>
<tbody>
<tr class="row-even"><td><p>macOS (Apple M4)</p></td>
<td><p>37.4k/s</p></td>
<td><p>420/s</p></td>
<td><p>89.09×</p></td>
</tr>
<tr class="row-odd"><td><p>Linux (i7-1260P)</p></td>
<td><p>25.3k/s</p></td>
<td><p>3.5k/s</p></td>
<td><p>7.19×</p></td>
</tr>
<tr class="row-even"><td><p>Windows (Ryzen 5 5600X)</p></td>
<td><p>30.8k/s</p></td>
<td><p>3.9k/s</p></td>
<td><p>8.00×</p></td>
</tr>
</tbody>
</table>
</div>
<p>Prns is consistent (25–37k/s). The reference artifact collapses to different depths on different hosts, and the single worst collapse - 420 packets per second on macOS - is the cell selected as the global headline. The “89×” is not a measure of Prns; it is a measure of how badly the broken baseline happened to fail on one host.</p>
<p>For reality calibration: Stock, interpreted RNS 1.5.4 on an ordinary mid-range laptop, single core, sustains roughly 30,000 single-packet deliveries per second (including ephemeral-key decryption), ~175,000–280,000 packets per second in transit relay, and on the order of 10 Gbps at 16 KiB payloads. The project’s “compiled” artifact measured 420–3,900 packets per second for its single-packet scenario: An order of magnitude or more <em>below</em> stock interpreted RNS. The comparison being marketed was not “Rust vs Python”; <strong>it was “an implementation running under optimal conditions versus a mislabeled, broken shim on a slow legacy interface at a severe policy disadvantage”</strong>.</p>
<p><strong>The equalized rows</strong></p>
<p>The project’s own “1 Gbps policy” rows, in which both sides are explicitly configured identically, publish ratios of roughly 2.4–8.4× across all hosts and scenarios - still against the broken baseline, but nowhere near 89×, and consistent with the ordinary, uncontroversial observation that a native implementation tends to outperform an interpreted one in raw throughput. That point needed no fudging to make, and is banal.</p>
<p>Interestingly, though, it seems that Prns is really only <em>marginally</em> faster than a Python implementation, running in interpreted mode, on a single CPU core.</p>
<p><strong>Assessment</strong></p>
<p>The front page says “Measured, not just claimed.” The record shows the opposite ordering: claimed, and arranged to look measured. No methodology section anywhere states what “compiled” means, that it is a deprecated development shim, that it builds debug targets, or which interface the reference was given; the one statement of the policy asymmetry appears in a footnote of the results tables themselves. If they did not need to fudge it, they would have published the method clearly.</p>
</section>
<section id="overall-evaluation">
<span id="brandolinis-prns-overall"></span><h3>Overall Evaluation<a class="headerlink" href="#overall-evaluation" title="Link to this heading"></a></h3>
<p>Evaluated against the conditions of <a class="reference internal" href="#brandolinis-evaluating"><span class="std std-ref">Evaluating A Reticulum Implementation</span></a>:</p>
<ul class="simple">
<li><p><strong>Provenance and attribution.</strong> Fails: The fake “ground-up” origin story; zero reference links
on the website; a single well-hidden link in the README; a license file reading
<code class="docutils literal notranslate"><span class="pre">Copyright</span> <span class="pre">(c)</span> <span class="pre">2026</span> <span class="pre">The</span> <span class="pre">Prns</span> <span class="pre">Authors</span></code> over work directly generated from the licensed reference;
no original copyright or permission notice anywhere.</p></li>
<li><p><strong>Agency and answerability.</strong> Fails on every criterion of <a class="reference internal" href="#brandolinis-assistance-versus-substitution"><span class="std std-ref">Assistance Versus Machine Substitution</span></a>:
Unauthored scope, uniform generation, discovery by regeneration, laundered provenance,
authorship by assignment.</p></li>
<li><p><strong>Engineering.</strong> Fails: The benchmark apparatus above; interop demonstrated only
against a pinned, outdated reference version over loopback while the marketing claims current
parity, interop failures with stock RNS; vendored prebuilt binaries and a republished fork
of an upstream crate (<code class="docutils literal notranslate"><span class="pre">nrf-softdevice</span> <span class="pre">0.1.0-prns.1</span></code>) with no verifiable provenance;
committed WASM bundles.</p></li>
<li><p><strong>Network behaviour.</strong> Fails: Invented spectrum behaviour and compatibility claims
about third-party applications of the reference ecosystem (Sideband, NomadNet, MeshChat)
that are not established by any evidence.</p></li>
<li><p><strong>Monetary and influence signals.</strong> The marketing apparatus - website before protocol,
day-three twelve-language marketing, false benchmark headlines, “audited” and “formal proof”
claims - the conformal surface described in <a class="reference internal" href="#brandolinis-evaluating"><span class="std std-ref">Evaluating A Reticulum Implementation</span></a>:
is where this project invested.</p></li>
</ul>
</section>
<section id="licensing-analysis">
<span id="brandolinis-prns-licensing"></span><h3>Licensing Analysis<a class="headerlink" href="#licensing-analysis" title="Link to this heading"></a></h3>
<p>Applying the two legal layers established in <a class="reference internal" href="#brandolinis-copyright-and-layers"><span class="std std-ref">Copyright &amp; The Two Legal Layers</span></a>:</p>
<p><strong>Layer A - copyright infringement (license-independent)</strong></p>
<p>The record shows a direct copy roundtrip: the licensed reference implementation fed into a machine, transformed, at a scale and cadence no human could review, with a license file asserting a fresh copyright in the operator’s name and no acknowledgment of the work the project was generated from. No substantial, new human creative input is demonstrated anywhere in the record - the founding document explicitly frames the design as an instructed port of the reference’s contract. A primarily machine-generated copy of a copyrighted work, not accompanied by demonstrable substantial human creative input, is a derivative work over which the copier holds no copyright, and a reproduction of which without the original author’s permission infringes the original author’s copyright. This holds under any license, MIT included. The operator’s copyright claim over the result is, on this evidence, not merely unsubstantiated; it is the absence of one, directly asserted in the project’s own writing.</p>
<p><strong>Layer B - license conditions (Reticulum License specific)</strong></p>
<p>Modern Reticulum - the current wire format, the AES-256-based link encryption, ratchets, the cryptographic machinery as it exists today - has been published under the Reticulum License since April 15, 2025, effective from release 0.9.4 and every release since. As a derivative of that work, the license’s conditions attach: The copyright and permission notice must be included in all copies and substantial portions; the AI-training condition must be honoured; the harm condition must be honoured. The record shows none of the notice requirements met, and a production process that consists of the licensed work being ingested into a machine and regurgitated, at industrial scale and cadence.</p>
<p><strong>The cascading consequence</strong></p>
<p>Prns is distributed claiming dual MIT/Apache-2.0 licensing. It is, however, a direct derivative of Reticulum-licensed work, and the claimed grant is therefore void. Every downstream project that builds on Prns believing it is MIT/Apache-licensed is building on a grant that does not exist. The users of Prns, and all software developers using it, have in effect, been placed under conditions they were never told about. The “ground-up” claim is not merely false; it is the sole load-bearing element of an entire licensing posture, and it fails spectacularly.</p>
</section>
<section id="consequences">
<span id="brandolinis-prns-consequences"></span><h3>Consequences<a class="headerlink" href="#consequences" title="Link to this heading"></a></h3>
<p>The consequences of this pattern are examined in the following sections - the harm to users and to the network in <a class="reference internal" href="#brandolinis-movement-of-a-dozen"><span class="std std-ref">A Movement Of A Dozen</span></a>, and the human dimension in <a class="reference internal" href="#brandolinis-health-and-coexistence"><span class="std std-ref">Network Health &amp; Coexistence</span></a>. This section’s contribution is narrower and intended as an instructive example: This is what a substitution project looks like, in full, on its own record. It is a reference example for <a class="reference internal" href="#brandolinis-evaluating"><span class="std std-ref">Evaluating A Reticulum Implementation</span></a>, and it demonstrates, in one case, most of the elements this chapter describes.</p>
</section>
<section id="verdict">
<span id="brandolinis-prns-verdict"></span><h3>Verdict<a class="headerlink" href="#verdict" title="Link to this heading"></a></h3>
<p>Applying the three verdicts of <a class="reference internal" href="#brandolinis-evaluating"><span class="std std-ref">Evaluating A Reticulum Implementation</span></a>, this project does not meet the standard. It is not “experimental but honest” - it is not labeled as experimental anywhere; the first thing users saw was a polished marketing presence promising a finished, tested, drop-in replacement. It is a project whose central claims are fabricated (the performance apparatus), whose provenance is laundered (the authorship machinery), whose foundation is misrepresented (the “ground-up” story), whose core semantics were learned late and by regeneration, and whose operator cannot possibly answer for any of it. It is also a blatant copyright violation of the reference implementation.</p>
<p>The proposed conclusion, for users and for the network: Treat the Prns project as hostile regardless of its polished surface, and as a hazard insofar as it invites users onto shared networks. Nothing in this section is a judgment about the people involved; it is a reading of the results produced, their history and how they came to be, which in the regrettable lack of any human authorship is the only thing that can be expected to be held to account.</p>
</section>
<section id="dating">
<span id="brandolinis-prns-dating"></span><h3>Dating<a class="headerlink" href="#dating" title="Link to this heading"></a></h3>
<p>This examination reflects the publicly available material as of September 2026; the repository in question continued to receive commits at the time of writing, so readers should treat citations to commits and files as point-in-time evidence. A <a class="reference external" href="https://github.com/markqvist/forensics_prns">forensics snapshot</a> is publicly available on GitHub.</p>
</section>
</section>
<section id="the-movement-of-a-dozen">
<span id="brandolinis-movement-of-a-dozen"></span><h2>The Movement Of A Dozen<a class="headerlink" href="#the-movement-of-a-dozen" title="Link to this heading"></a></h2>
<section id="presentation-elongated">
@ -1239,6 +1042,203 @@ defended.</p></li>
<p><em>Mark</em></p>
</section>
</section>
<section id="addendum-a-the-prns-case">
<span id="brandolinis-prns"></span><h2>Addendum A: The Prns Case<a class="headerlink" href="#addendum-a-the-prns-case" title="Link to this heading"></a></h2>
<section id="purpose-scope">
<span id="brandolinis-purpose-and-scope"></span><h3>Purpose &amp; Scope<a class="headerlink" href="#purpose-scope" title="Link to this heading"></a></h3>
<p>This section provides a concrete example, which future evaluations can use as a template. Its purpose is not to be the last word on this particular subject, but to be an example of how the ideas in this chapter can be applied, and to make the next such examination easier.</p>
<p>The subject of this case study is <strong>Prns</strong>, a project published at the repository <code class="docutils literal notranslate"><span class="pre">github.com/KenAKAFrosty/Prns</span></code>, presented as a “ground-up implementation of Reticulum, written in Rust”, marketed as faster, safer, and more strictly tested than the reference, and widely promoted with the claim of “up to 89× the throughput” of the reference implementation. The record described below is the project’s own, and sourced from its GitHub repository, analyzed locally.</p>
</section>
<section id="the-project-in-brief">
<span id="brandolinis-project-in-brief"></span><h3>The Project In Brief<a class="headerlink" href="#the-project-in-brief" title="Link to this heading"></a></h3>
<ul class="simple">
<li><p><strong>Time span.</strong> 3,374 commits between 2026-05-26 and 2026-09-12: approximately 110 days,
at a mean rate of ~31 commits per day. Monthly: 132 / 1,137 / 1,097 / 805 / 203.</p></li>
<li><p><strong>Authorship.</strong> 3,252 of 3,374 commits (96.4%) are authored by a single account. A
second identity, “Prns Tests <a class="reference external" href="mailto:tests&#37;&#52;&#48;example&#46;test">tests<span>&#64;</span>example<span>&#46;</span>test</a>” - a fictitious identity on a reserved
domain - contributed 35 commits, every one of them website and marketing content.</p></li>
<li><p><strong>Size.</strong> 3,519 tracked files; 1,983 Rust files; 636,226 lines of Rust; approximately
22.7 MB of Rust source; 69.5 MB of total repository content.</p></li>
<li><p><strong>Scope claimed.</strong> A daemon (“drop-in replacement” for the reference daemon), embedded
firmware for three microcontroller families (including six ESP32-S3 board variants and
nRF52840), SDKs and bindings for nine languages, a browser-based node and web flasher, a
twelve-language website, a benchmark apparatus with its own publication and “proof”
pipeline, and a validation hub with oracles, fuzzing, mutation testing, and formal-proof
claims.</p></li>
<li><p><strong>Marketing claims.</strong> “Ground-up implementation of Reticulum”; “up to 89× the
throughput”; “48× smaller peak-memory footprint”; “33× the energy efficiency”;
“Measured, not just claimed”; “Enforced, then audited”; “byte-for-byte wire parity with
the reference implementation”; “works with Sideband, NomadNet, MeshChat, etc.”;
“no_std (no alloc required either)”.</p></li>
<li><p><strong>Status at the time of writing.</strong> Version 0.3.7; published version history begins at
0.3.0. The repository continues to receive commits.</p></li>
</ul>
</section>
<section id="question-1-is-this-a-clean-implementation-or-was-it-directly-generated-from-the-reference">
<span id="brandolinis-prns-question-1"></span><h3>Question 1: Is this a clean implementation, or was it directly generated from the reference?<a class="headerlink" href="#question-1-is-this-a-clean-implementation-or-was-it-directly-generated-from-the-reference" title="Link to this heading"></a></h3>
<p>The first of the two deciding questions from <a class="reference internal" href="#brandolinis-evaluating"><span class="std std-ref">Evaluating A Reticulum Implementation</span></a> is settled by the project’s own record. An actual <a class="reference internal" href="#brandolinis-cleanroom-delusion"><span class="std std-ref">clean-room</span></a> implementation, reasoned out and written by humans, would owe nothing to any license. The data available shows clearly that Prns is not that.</p>
<ul class="simple">
<li><p><strong>The founding state.</strong> The first commit, “Scaffold Personal Reticulum suite”, contains
the scaffolding of not one but two ports - <code class="docutils literal notranslate"><span class="pre">personal-rns</span></code> and <code class="docutils literal notranslate"><span class="pre">personal-lxmf</span></code>, the latter
being the reference’s companion messaging protocol - together with a daemon scaffold and
a 233-line founding document, <code class="docutils literal notranslate"><span class="pre">docs/build-ethos.md</span></code>. That document declares the project’s
goal as a “performance-focused drop-in-replacement for rnsd” and its governing principle
as: “Port the contract, not the implementation.” It further states directly to the
machine-loop, that <strong>“You owe the reference fidelity at exactly two boundaries:
The wire… The behavior. … Between those two boundaries, the model is yours”</strong>.
At this point, the very first commit, effectively the whole of the implementation design
and any relevant decisions are handed over to the LLM.</p></li>
<li><p><strong>Continuous ingestion from the reference.</strong> 506 commits reference RNS or Reticulum
source behaviour; the word “parity” appears in 49 commit messages. Commits cite the reference
implementation’s own source locations (for example <code class="docutils literal notranslate"><span class="pre">Transport.py:1367</span></code>) when correcting
their own divergences and mistakes.</p></li>
<li><p><strong>Byte-level fidelity as an explicit goal.</strong> Within 48 hours of the first commit, the
record shows a “crypto adapter - vetted primitives, byte-exact vs RNS 1.3.1”, and a wire
implementation matching the reference’s packet header layout. The project’s own
validation apparatus decodes wire vectors using the reference implementation’s own
packet parser, and the interop suite consists of real, stock-RNS peer nodes - that is,
the reference source itself, used as the ground truth against which this LLM output is
checked, and committed as accepted and verified after 48 hours of the project’s recorded start.</p></li>
<li><p><strong>The marketing mismatch.</strong> The same record that documents all of the above describes the
project, publicly, as “a ground-up implementation of Reticulum” - while declining, on its
website, to link to the reference implementation at all: the entire tree mentions the
reference’s author in six files, and the website in none.</p></li>
</ul>
<p>Conclusion: the project’s own history and commit record establishes that it was generated directly from the reference implementation’s source code, not reasoned out from the public-domain protocol. It is a derivative of licensed work within the meaning of <a class="reference internal" href="#brandolinis-what-the-license-is"><span class="std std-ref">the Reticulum License</span></a> and <a class="reference internal" href="#brandolinis-copyright-and-layers"><span class="std std-ref">general copyright law</span></a>. The “ground-up” claim, which carries its entire legal and marketing posture, is disproven by the project’s own history.</p>
</section>
<section id="question-2-who-or-what-is-the-agent-of-the-work">
<span id="brandolinis-prns-question-2"></span><h3>Question 2: Who, or what, is the agent of the work?<a class="headerlink" href="#question-2-who-or-what-is-the-agent-of-the-work" title="Link to this heading"></a></h3>
<p>The second deciding question is answered by the application of <a class="reference internal" href="#brandolinis-assistance-versus-substitution"><span class="std std-ref">Assistance Versus Machine Substitution</span></a> criteria to the project.</p>
<p><strong>Scope that no human could have authored</strong></p>
<p>636,226 lines of Rust in 110 days is approximately 5,800 lines per day, every day, including weekends - with 149 commits recorded between midnight and 06:00, and Saturday the single busiest weekday. No human review or decision capacity is commensurable with this volume; the review capacity and the output volume are structurally incommensurable, which is the definition of unauthored scope.</p>
<p><strong>Uniform generation</strong></p>
<p>The record shows no sign of human development, growth, or learning: No contested decisions, no style drift. Instead: endless renaming (in the first 48 hours: <code class="docutils literal notranslate"><span class="pre">State</span> <span class="pre">→</span> <span class="pre">EngineState</span> <span class="pre">→</span> <span class="pre">TickInput</span> <span class="pre">→</span> <span class="pre">TickOutput</span></code>), uniform fluent register in every commit, and the exact same, synthetic voice in code, documentation, and website copy.</p>
<p><strong>Discovery by regeneration</strong></p>
<p>Corrections arrived by the machine’s own subsequent runs, recorded as planned milestones. In early July 2026, a series of “core review” commits documented, in the project’s own words:</p>
<ul class="simple">
<li><p>announce-ID history “was unbounded per-slot growth” (<code class="docutils literal notranslate"><span class="pre">54cc8d601</span></code>);</p></li>
<li><p>interface announce limiting could “leak a sustained flood” (<code class="docutils literal notranslate"><span class="pre">9d27af75c</span></code>);</p></li>
<li><p>a “phantom-airtime leak” where frames “used to vanish silently” (<code class="docutils literal notranslate"><span class="pre">4ed75ffdd</span></code>);</p></li>
<li><p>Group-packet deduplication “which RNS does not do” - a behaviour the reference never had,
implemented and later removed (<code class="docutils literal notranslate"><span class="pre">edd8e72be</span></code>);</p></li>
<li><p>“both <code class="docutils literal notranslate"><span class="pre">unwrap_or(&amp;[])</span></code> arms were unreachable dead defaults” (<code class="docutils literal notranslate"><span class="pre">74bea355e</span></code>);</p></li>
<li><p>a benchmark crate “hasn’t compiled since” a prior rename, undetected for weeks because it
was outside the CI’s workspace (<code class="docutils literal notranslate"><span class="pre">86240b027</span></code>).</p></li>
</ul>
<p>Earlier still: the record shows a “&gt;1 MiB RNS-to-Prns interop stall” closed three weeks in
(<code class="docutils literal notranslate"><span class="pre">cc4d524a3</span></code>), and a known send-path hang shipped with the note “typed fast-fail a
candidate for later” (<code class="docutils literal notranslate"><span class="pre">a010e6613</span></code>).</p>
<p><strong>Laundered provenance</strong></p>
<p>The repository contains a committed commit-message hook (<code class="docutils literal notranslate"><span class="pre">.githooks/commit-msg</span></code>) that <em>blocks</em> any commit containing attribution for machine generation (“generated with claude/codex/copilot/cursor/gemini”, “co-authored-by”), with the explanation “The committer owns the commit”. The contributing guide is explicit: “AI tools … are welcome … what you submit is <em>yours</em>”, and describes the contributing population as “both human and automated contributors”. The fictitious “Prns Tests” identity completes the picture: A manufactured, unknowable contributor, used for marketing content.</p>
<p><strong>Authorship by assignment</strong></p>
<p>The human whose name is on the work cannot answer for it, because the choices were never made by a human, and only the general shape and constraints of the outward presentation was. Nothing in the project’s history shows an individual explaining a design decision, accepting a mistake in the first person, or going deeper under technical questioning; the record shows process language and marketing instead. Per the earlier mentioned test: any other person could have pressed the same button, and nothing would be different. The project is effectively unowned, and void of value.</p>
<p>By the criteria of <a class="reference internal" href="#brandolinis-assistance-versus-substitution"><span class="std std-ref">Assistance Versus Machine Substitution</span></a>, this is substitution. The machine was the agent of the work; the “author” was a facade.</p>
</section>
<section id="the-performance-claims">
<span id="brandolinis-prns-performance"></span><h3>The performance claims<a class="headerlink" href="#the-performance-claims" title="Link to this heading"></a></h3>
<p>The project’s central marketing claim - “up to 89× the throughput” of the reference - is also its most completely documented failure, because the project published the evidence of its own measurement. The apparatus, the results, and the problems are all on the record.</p>
<p><strong>The claim</strong></p>
<p>The README states “up to 89× the throughput”; the on-network marketing page repeats “up to 89× the throughput, 48× smaller peak-memory footprint, and 33× the energy efficiency of stock RNS 1.4.2”; the website’s front page carries the tagline “Measured, not just claimed”.</p>
<p><strong>The apparatus</strong></p>
<p>The reference is loaded through <code class="docutils literal notranslate"><span class="pre">benchmarks/reference/compiled_reference.py</span></code>, which installs <code class="docutils literal notranslate"><span class="pre">pyximport</span></code> and then asserts two things: that <code class="docutils literal notranslate"><span class="pre">RNS.compiled</span> <span class="pre">==</span> <span class="pre">True</span></code>, and that at least <em>one</em> RNS module was loaded from a native extension. The project’s own published “proof” records show exactly what those checks captured, on every platform:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">aarch64</span><span class="o">-</span><span class="n">apple</span><span class="o">-</span><span class="n">darwin</span><span class="p">:</span> <span class="o">.../</span><span class="n">RNS</span><span class="o">.</span><span class="n">cpython</span><span class="o">-</span><span class="mi">313</span><span class="o">-</span><span class="n">darwin</span><span class="o">.</span><span class="n">so</span><span class="p">,</span> <span class="n">Cython</span> <span class="mf">3.2.8</span><span class="p">,</span> <span class="n">Python</span> <span class="mf">3.13.13</span>
<span class="n">x86_64</span><span class="o">-</span><span class="n">unknown</span><span class="o">-</span><span class="n">linux</span><span class="o">-</span><span class="n">gnu</span><span class="p">:</span> <span class="o">.../</span><span class="n">RNS</span><span class="o">.</span><span class="n">cpython</span><span class="o">-</span><span class="mi">313</span><span class="o">-</span><span class="n">x86_64</span><span class="o">-</span><span class="n">linux</span><span class="o">-</span><span class="n">gnu</span><span class="o">.</span><span class="n">so</span><span class="p">,</span> <span class="n">gcc</span> <span class="mf">11.4.0</span>
<span class="n">x86_64</span><span class="o">-</span><span class="n">pc</span><span class="o">-</span><span class="n">windows</span><span class="o">-</span><span class="n">msvc</span><span class="p">:</span> <span class="o">~/.</span><span class="n">prns</span><span class="o">-</span><span class="n">oc</span><span class="o">/</span><span class="n">lib</span><span class="o">.</span><span class="n">win</span><span class="o">-</span><span class="n">amd64</span><span class="o">-</span><span class="n">cpython</span><span class="o">-</span><span class="mi">313</span><span class="o">/</span><span class="n">RNS</span><span class="o">.</span><span class="n">cp313</span><span class="o">-</span><span class="n">win_amd64</span><span class="o">.</span><span class="n">pyd</span>
</pre></div>
</div>
<p>In every case the recorded native module is the <strong>top-level package only</strong> - <code class="docutils literal notranslate"><span class="pre">RNS.so</span></code>, nothing below it. Nothing named <code class="docutils literal notranslate"><span class="pre">RNS.Transport</span></code>, <code class="docutils literal notranslate"><span class="pre">RNS.Destination</span></code>, <code class="docutils literal notranslate"><span class="pre">RNS.Packet</span></code>, <code class="docutils literal notranslate"><span class="pre">RNS.Link</span></code>, or <code class="docutils literal notranslate"><span class="pre">RNS.Resource</span></code> ever appears, because <em>nothing below the top level was ever compiled</em>. Nobody bothered to check or verify <em>anything</em> here.</p>
<p>The machine output was simply taken for truth, and a full marketing strategy was spun and produced on it. “RNS 1.4.2 (compiled)” - the label used in every table, chart, and marketing page - <em>is not a mode of RNS that exists</em>, but the hallucinations of a machine, which the humans created a marketing strategy on. In reality, it is the old <code class="docutils literal notranslate"><span class="pre">CRNS</span></code> development shim, whose top-level-only, debug-oriented “compilation” is slower than plain interpreted RNS, and which was <em>defunct for over a year</em> before these benchmarks were published.</p>
<p><strong>Interface choices</strong></p>
<p>The harness writes the reference’s configuration itself (<code class="docutils literal notranslate"><span class="pre">benchmarks/reference/participant_node.py</span></code>): <code class="docutils literal notranslate"><span class="pre">TCPClientInterface</span></code> for the initiator, <code class="docutils literal notranslate"><span class="pre">TCPServerInterface</span></code> for the responder and both relay sides, with <code class="docutils literal notranslate"><span class="pre">UDPInterface</span></code> as the abstract wire. The reference was never given its modern <code class="docutils literal notranslate"><span class="pre">BackboneInterface</span></code> on any platform, forcing the slowest possible interrfaces. The interface selection is never mentioned in any methodology text.</p>
<p><strong>The policy</strong></p>
<p>The published default-policy tables record the asymmetry directly: Prns at 500 Mbps / 128 KiB TCP policy against the reference at 10 Mbps / 8 KiB - slyly footnoted as “preserves each implementation’s normal TCP policy” (in the case of RNS, a conservative default policy that was selected to prioritize coexistence on slower, shared links, requiring the user to dial it up to full speed if they knew what they were doing). Raw transport “throughput” ratios of 20.65× (Linux) and 38.84× (Windows) are therefore mostly policy, not engine.</p>
<p><strong>The cross-host evidence</strong></p>
<p>The published results show the same scenario producing wildly different ratios by host, and the variance is entirely in the reference artifact:</p>
<div class="table-wrapper docutils container">
<table class="docutils align-default">
<thead>
<tr class="row-odd"><th class="head"><p>Host</p></th>
<th class="head"><p>Prns, single-packet</p></th>
<th class="head"><p>“Reference”, single-packet</p></th>
<th class="head"><p>Ratio</p></th>
</tr>
</thead>
<tbody>
<tr class="row-even"><td><p>macOS (Apple M4)</p></td>
<td><p>37.4k/s</p></td>
<td><p>420/s</p></td>
<td><p>89.09×</p></td>
</tr>
<tr class="row-odd"><td><p>Linux (i7-1260P)</p></td>
<td><p>25.3k/s</p></td>
<td><p>3.5k/s</p></td>
<td><p>7.19×</p></td>
</tr>
<tr class="row-even"><td><p>Windows (Ryzen 5 5600X)</p></td>
<td><p>30.8k/s</p></td>
<td><p>3.9k/s</p></td>
<td><p>8.00×</p></td>
</tr>
</tbody>
</table>
</div>
<p>Prns is consistent (25–37k/s). The reference artifact collapses to different depths on different hosts, and the single worst collapse - 420 packets per second on macOS - is the cell selected as the global headline. The “89×” is not a measure of Prns; it is a measure of how badly the broken baseline happened to fail on one host.</p>
<p>For reality calibration: Stock, interpreted RNS 1.5.4 on an ordinary mid-range laptop, single core, sustains roughly 30,000 single-packet deliveries per second (including ephemeral-key decryption), ~175,000–280,000 packets per second in transit relay, and on the order of 10 Gbps at 16 KiB payloads. The project’s “compiled” artifact measured 420–3,900 packets per second for its single-packet scenario: An order of magnitude or more <em>below</em> stock interpreted RNS. The comparison being marketed was not “Rust vs Python”; <strong>it was “an implementation running under optimal conditions versus a mislabeled, broken shim on a slow legacy interface at a severe policy disadvantage”</strong>.</p>
<p><strong>The equalized rows</strong></p>
<p>The project’s own “1 Gbps policy” rows, in which both sides are explicitly configured identically, publish ratios of roughly 2.4–8.4× across all hosts and scenarios - still against the broken baseline, but nowhere near 89×, and consistent with the ordinary, uncontroversial observation that a native implementation tends to outperform an interpreted one in raw throughput. That point needed no fudging to make, and is banal.</p>
<p>Interestingly, though, it seems that Prns is really only <em>marginally</em> faster than a Python implementation, running in interpreted mode, on a single CPU core.</p>
<p><strong>Assessment</strong></p>
<p>The front page says “Measured, not just claimed.” The record shows the opposite ordering: claimed, and arranged to look measured. No methodology section anywhere states what “compiled” means, that it is a deprecated development shim, that it builds debug targets, or which interface the reference was given; the one statement of the policy asymmetry appears in a footnote of the results tables themselves. If they did not need to fudge it, they would have published the method clearly.</p>
</section>
<section id="overall-evaluation">
<span id="brandolinis-prns-overall"></span><h3>Overall Evaluation<a class="headerlink" href="#overall-evaluation" title="Link to this heading"></a></h3>
<p>Evaluated against the conditions of <a class="reference internal" href="#brandolinis-evaluating"><span class="std std-ref">Evaluating A Reticulum Implementation</span></a>:</p>
<ul class="simple">
<li><p><strong>Provenance and attribution.</strong> Fails: The fake “ground-up” origin story; zero reference links
on the website; a single well-hidden link in the README; a license file reading
<code class="docutils literal notranslate"><span class="pre">Copyright</span> <span class="pre">(c)</span> <span class="pre">2026</span> <span class="pre">The</span> <span class="pre">Prns</span> <span class="pre">Authors</span></code> over work directly generated from the licensed reference;
no original copyright or permission notice anywhere.</p></li>
<li><p><strong>Agency and answerability.</strong> Fails on every criterion of <a class="reference internal" href="#brandolinis-assistance-versus-substitution"><span class="std std-ref">Assistance Versus Machine Substitution</span></a>:
Unauthored scope, uniform generation, discovery by regeneration, laundered provenance,
authorship by assignment.</p></li>
<li><p><strong>Engineering.</strong> Fails: The benchmark apparatus above; interop demonstrated only
against a pinned, outdated reference version over loopback while the marketing claims current
parity, interop failures with stock RNS; vendored prebuilt binaries and a republished fork
of an upstream crate (<code class="docutils literal notranslate"><span class="pre">nrf-softdevice</span> <span class="pre">0.1.0-prns.1</span></code>) with no verifiable provenance;
committed WASM bundles.</p></li>
<li><p><strong>Network behaviour.</strong> Fails: Invented spectrum behaviour and compatibility claims
about third-party applications of the reference ecosystem (Sideband, NomadNet, MeshChat)
that are not established by any evidence.</p></li>
<li><p><strong>Monetary and influence signals.</strong> The marketing apparatus - website before protocol,
day-three twelve-language marketing, false benchmark headlines, “audited” and “formal proof”
claims - the conformal surface described in <a class="reference internal" href="#brandolinis-evaluating"><span class="std std-ref">Evaluating A Reticulum Implementation</span></a>:
is where this project invested.</p></li>
</ul>
</section>
<section id="licensing-analysis">
<span id="brandolinis-prns-licensing"></span><h3>Licensing Analysis<a class="headerlink" href="#licensing-analysis" title="Link to this heading"></a></h3>
<p>Applying the two legal layers established in <a class="reference internal" href="#brandolinis-copyright-and-layers"><span class="std std-ref">Copyright &amp; The Two Legal Layers</span></a>:</p>
<p><strong>Layer A - copyright infringement (license-independent)</strong></p>
<p>The record shows a direct copy roundtrip: the licensed reference implementation fed into a machine, transformed, at a scale and cadence no human could review, with a license file asserting a fresh copyright in the operator’s name and no acknowledgment of the work the project was generated from. No substantial, new human creative input is demonstrated anywhere in the record - the founding document explicitly frames the design as an instructed port of the reference’s contract. A primarily machine-generated copy of a copyrighted work, not accompanied by demonstrable substantial human creative input, is a derivative work over which the copier holds no copyright, and a reproduction of which without the original author’s permission infringes the original author’s copyright. This holds under any license, MIT included. The operator’s copyright claim over the result is, on this evidence, not merely unsubstantiated; it is the absence of one, directly asserted in the project’s own writing.</p>
<p><strong>Layer B - license conditions (Reticulum License specific)</strong></p>
<p>Modern Reticulum - the current wire format, the AES-256-based link encryption, ratchets, the cryptographic machinery as it exists today - has been published under the Reticulum License since April 15, 2025, effective from release 0.9.4 and every release since. As a derivative of that work, the license’s conditions attach: The copyright and permission notice must be included in all copies and substantial portions; the AI-training condition must be honoured; the harm condition must be honoured. The record shows none of the notice requirements met, and a production process that consists of the licensed work being ingested into a machine and regurgitated, at industrial scale and cadence.</p>
<p><strong>The cascading consequence</strong></p>
<p>Prns is distributed claiming dual MIT/Apache-2.0 licensing. It is, however, a direct derivative of Reticulum-licensed work, and the claimed grant is therefore void. Every downstream project that builds on Prns believing it is MIT/Apache-licensed is building on a grant that does not exist. The users of Prns, and all software developers using it, have in effect, been placed under conditions they were never told about. The “ground-up” claim is not merely false; it is the sole load-bearing element of an entire licensing posture, and it fails spectacularly.</p>
</section>
<section id="consequences">
<span id="brandolinis-prns-consequences"></span><h3>Consequences<a class="headerlink" href="#consequences" title="Link to this heading"></a></h3>
<p>The consequences of this pattern are examined in the following sections: The harm to users and to the network in <a class="reference internal" href="#brandolinis-movement-of-a-dozen"><span class="std std-ref">A Movement Of A Dozen</span></a>, and the human dimension in <a class="reference internal" href="#brandolinis-health-and-coexistence"><span class="std std-ref">Network Health &amp; Coexistence</span></a>. The contribution of this addendum is narrower and intended as an instructive example: This is what a substitution project looks like, in full, on its own record. It is a reference example for <a class="reference internal" href="#brandolinis-evaluating"><span class="std std-ref">Evaluating A Reticulum Implementation</span></a>, and it demonstrates, in one case, most of the elements this chapter describes.</p>
</section>
<section id="verdict">
<span id="brandolinis-prns-verdict"></span><h3>Verdict<a class="headerlink" href="#verdict" title="Link to this heading"></a></h3>
<p>Applying the three verdicts of <a class="reference internal" href="#brandolinis-evaluating"><span class="std std-ref">Evaluating A Reticulum Implementation</span></a>, this project does not meet the standard. It is not “experimental but honest” - it is not labeled as experimental anywhere; the first thing users saw was a polished marketing presence promising a finished, tested, drop-in replacement. It is a project whose central claims are fabricated (the performance apparatus), whose provenance is laundered (the authorship machinery), whose foundation is misrepresented (the “ground-up” story), whose core semantics were learned late and by regeneration, and whose operator cannot possibly answer for any of it. It is also a blatant copyright violation of the reference implementation.</p>
<p>The proposed conclusion, for users and for the network: Treat the Prns project as hostile regardless of its polished surface, and as a hazard insofar as it invites users onto shared networks. Nothing in this section is a judgment about the people involved; it is a reading of the results produced, their history and how they came to be, which in the regrettable lack of any human authorship is the only thing that can be expected to be held to account.</p>
</section>
<section id="dating">
<span id="brandolinis-prns-dating"></span><h3>Dating<a class="headerlink" href="#dating" title="Link to this heading"></a></h3>
<p>This examination reflects the publicly available material as of September 2026; the repository in question continued to receive commits at the time of writing, so readers should treat citations to commits and files as point-in-time evidence. A <a class="reference external" href="https://github.com/markqvist/forensics_prns">forensics snapshot</a> is publicly available on GitHub.</p>
</section>
</section>
</section>
</article>
@ -1342,19 +1342,6 @@ defended.</p></li>
<li><a class="reference internal" href="#these-standards-are-reasonable">These Standards Are Reasonable</a></li>
</ul>
</li>
<li><a class="reference internal" href="#the-prns-case">The Prns Case</a><ul>
<li><a class="reference internal" href="#purpose-scope">Purpose &amp; Scope</a></li>
<li><a class="reference internal" href="#the-project-in-brief">The Project In Brief</a></li>
<li><a class="reference internal" href="#question-1-is-this-a-clean-implementation-or-was-it-directly-generated-from-the-reference">Question 1: Is this a clean implementation, or was it directly generated from the reference?</a></li>
<li><a class="reference internal" href="#question-2-who-or-what-is-the-agent-of-the-work">Question 2: Who, or what, is the agent of the work?</a></li>
<li><a class="reference internal" href="#the-performance-claims">The performance claims</a></li>
<li><a class="reference internal" href="#overall-evaluation">Overall Evaluation</a></li>
<li><a class="reference internal" href="#licensing-analysis">Licensing Analysis</a></li>
<li><a class="reference internal" href="#consequences">Consequences</a></li>
<li><a class="reference internal" href="#verdict">Verdict</a></li>
<li><a class="reference internal" href="#dating">Dating</a></li>
</ul>
</li>
<li><a class="reference internal" href="#the-movement-of-a-dozen">The Movement Of A Dozen</a><ul>
<li><a class="reference internal" href="#presentation-elongated">Presentation, Elongated</a></li>
<li><a class="reference internal" href="#headcount">Headcount</a></li>
@ -1376,6 +1363,19 @@ defended.</p></li>
<li><a class="reference internal" href="#defence-of-the-commons">Defence Of The Commons</a></li>
</ul>
</li>
<li><a class="reference internal" href="#addendum-a-the-prns-case">Addendum A: The Prns Case</a><ul>
<li><a class="reference internal" href="#purpose-scope">Purpose &amp; Scope</a></li>
<li><a class="reference internal" href="#the-project-in-brief">The Project In Brief</a></li>
<li><a class="reference internal" href="#question-1-is-this-a-clean-implementation-or-was-it-directly-generated-from-the-reference">Question 1: Is this a clean implementation, or was it directly generated from the reference?</a></li>
<li><a class="reference internal" href="#question-2-who-or-what-is-the-agent-of-the-work">Question 2: Who, or what, is the agent of the work?</a></li>
<li><a class="reference internal" href="#the-performance-claims">The performance claims</a></li>
<li><a class="reference internal" href="#overall-evaluation">Overall Evaluation</a></li>
<li><a class="reference internal" href="#licensing-analysis">Licensing Analysis</a></li>
<li><a class="reference internal" href="#consequences">Consequences</a></li>
<li><a class="reference internal" href="#verdict">Verdict</a></li>
<li><a class="reference internal" href="#dating">Dating</a></li>
</ul>
</li>
</ul>
</li>
</ul>

26
docs/manual/index.html
View file

@ -672,19 +672,6 @@ to participate in the development of Reticulum itself.</p>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#these-standards-are-reasonable">These Standards Are Reasonable</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="brandolinis.html#the-prns-case">The Prns Case</a><ul>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#purpose-scope">Purpose &amp; Scope</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#the-project-in-brief">The Project In Brief</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#question-1-is-this-a-clean-implementation-or-was-it-directly-generated-from-the-reference">Question 1: Is this a clean implementation, or was it directly generated from the reference?</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#question-2-who-or-what-is-the-agent-of-the-work">Question 2: Who, or what, is the agent of the work?</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#the-performance-claims">The performance claims</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#overall-evaluation">Overall Evaluation</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#licensing-analysis">Licensing Analysis</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#consequences">Consequences</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#verdict">Verdict</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#dating">Dating</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="brandolinis.html#the-movement-of-a-dozen">The Movement Of A Dozen</a><ul>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#presentation-elongated">Presentation, Elongated</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#headcount">Headcount</a></li>
@ -706,6 +693,19 @@ to participate in the development of Reticulum itself.</p>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#defence-of-the-commons">Defence Of The Commons</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="brandolinis.html#addendum-a-the-prns-case">Addendum A: The Prns Case</a><ul>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#purpose-scope">Purpose &amp; Scope</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#the-project-in-brief">The Project In Brief</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#question-1-is-this-a-clean-implementation-or-was-it-directly-generated-from-the-reference">Question 1: Is this a clean implementation, or was it directly generated from the reference?</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#question-2-who-or-what-is-the-agent-of-the-work">Question 2: Who, or what, is the agent of the work?</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#the-performance-claims">The performance claims</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#overall-evaluation">Overall Evaluation</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#licensing-analysis">Licensing Analysis</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#consequences">Consequences</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#verdict">Verdict</a></li>
<li class="toctree-l3"><a class="reference internal" href="brandolinis.html#dating">Dating</a></li>
</ul>
</li>
</ul>
</li>
</ul>

BIN
docs/manual/objects.inv
View file

Binary file not shown.

2
docs/manual/searchindex.js
View file

File diff suppressed because one or more lines are too long

446
docs/markdown/brandolinis.md
View file

@ -617,228 +617,6 @@ I’ll close this guide by stating what these standards are *not*: They are neit
The reference implementation has met this standard for years, and its users know what that looks like.
## The Prns Case
### Purpose & Scope
This section provides a concrete example, which future evaluations can use as a template. Its purpose is not to be the last word on this particular subject, but to be an example of how the ideas in this chapter can be applied, and to make the next such examination easier.
The subject of this case study is **Prns**, a project published at the repository `github.com/KenAKAFrosty/Prns`, presented as a “ground-up implementation of Reticulum, written in Rust”, marketed as faster, safer, and more strictly tested than the reference, and widely promoted with the claim of “up to 89× the throughput” of the reference implementation. The record described below is the project’s own, and sourced from its GitHub repository, analyzed locally.
### The Project In Brief
* **Time span.** 3,374 commits between 2026-05-26 and 2026-09-12: approximately 110 days,
at a mean rate of ~31 commits per day. Monthly: 132 / 1,137 / 1,097 / 805 / 203.
* **Authorship.** 3,252 of 3,374 commits (96.4%) are authored by a single account. A
second identity, “Prns Tests [tests@example.test](mailto:tests@example.test)” - a fictitious identity on a reserved
domain - contributed 35 commits, every one of them website and marketing content.
* **Size.** 3,519 tracked files; 1,983 Rust files; 636,226 lines of Rust; approximately
22.7 MB of Rust source; 69.5 MB of total repository content.
* **Scope claimed.** A daemon (“drop-in replacement” for the reference daemon), embedded
firmware for three microcontroller families (including six ESP32-S3 board variants and
nRF52840), SDKs and bindings for nine languages, a browser-based node and web flasher, a
twelve-language website, a benchmark apparatus with its own publication and “proof”
pipeline, and a validation hub with oracles, fuzzing, mutation testing, and formal-proof
claims.
* **Marketing claims.** “Ground-up implementation of Reticulum”; “up to 89× the
throughput”; “48× smaller peak-memory footprint”; “33× the energy efficiency”;
“Measured, not just claimed”; “Enforced, then audited”; “byte-for-byte wire parity with
the reference implementation”; “works with Sideband, NomadNet, MeshChat, etc.”;
“no_std (no alloc required either)”.
* **Status at the time of writing.** Version 0.3.7; published version history begins at
0.3.0. The repository continues to receive commits.
### Question 1: Is this a clean implementation, or was it directly generated from the reference?
The first of the two deciding questions from [Evaluating A Reticulum Implementation](#brandolinis-evaluating) is settled by the project’s own record. An actual [clean-room](#brandolinis-cleanroom-delusion) implementation, reasoned out and written by humans, would owe nothing to any license. The data available shows clearly that Prns is not that.
* **The founding state.** The first commit, “Scaffold Personal Reticulum suite”, contains
the scaffolding of not one but two ports - `personal-rns` and `personal-lxmf`, the latter
being the reference’s companion messaging protocol - together with a daemon scaffold and
a 233-line founding document, `docs/build-ethos.md`. That document declares the project’s
goal as a “performance-focused drop-in-replacement for rnsd” and its governing principle
as: “Port the contract, not the implementation.” It further states directly to the
machine-loop, that **“You owe the reference fidelity at exactly two boundaries:
The wire… The behavior. … Between those two boundaries, the model is yours”**.
At this point, the very first commit, effectively the whole of the implementation design
and any relevant decisions are handed over to the LLM.
* **Continuous ingestion from the reference.** 506 commits reference RNS or Reticulum
source behaviour; the word “parity” appears in 49 commit messages. Commits cite the reference
implementation’s own source locations (for example `Transport.py:1367`) when correcting
their own divergences and mistakes.
* **Byte-level fidelity as an explicit goal.** Within 48 hours of the first commit, the
record shows a “crypto adapter - vetted primitives, byte-exact vs RNS 1.3.1”, and a wire
implementation matching the reference’s packet header layout. The project’s own
validation apparatus decodes wire vectors using the reference implementation’s own
packet parser, and the interop suite consists of real, stock-RNS peer nodes - that is,
the reference source itself, used as the ground truth against which this LLM output is
checked, and committed as accepted and verified after 48 hours of the project’s recorded start.
* **The marketing mismatch.** The same record that documents all of the above describes the
project, publicly, as “a ground-up implementation of Reticulum” - while declining, on its
website, to link to the reference implementation at all: the entire tree mentions the
reference’s author in six files, and the website in none.
Conclusion: the project’s own history and commit record establishes that it was generated directly from the reference implementation’s source code, not reasoned out from the public-domain protocol. It is a derivative of licensed work within the meaning of [the Reticulum License](#brandolinis-what-the-license-is) and [general copyright law](#brandolinis-copyright-and-layers). The “ground-up” claim, which carries its entire legal and marketing posture, is disproven by the project’s own history.
### Question 2: Who, or what, is the agent of the work?
The second deciding question is answered by the application of [Assistance Versus Machine Substitution](#brandolinis-assistance-versus-substitution) criteria to the project.
**Scope that no human could have authored**
636,226 lines of Rust in 110 days is approximately 5,800 lines per day, every day, including weekends - with 149 commits recorded between midnight and 06:00, and Saturday the single busiest weekday. No human review or decision capacity is commensurable with this volume; the review capacity and the output volume are structurally incommensurable, which is the definition of unauthored scope.
**Uniform generation**
The record shows no sign of human development, growth, or learning: No contested decisions, no style drift. Instead: endless renaming (in the first 48 hours: `State → EngineState → TickInput → TickOutput`), uniform fluent register in every commit, and the exact same, synthetic voice in code, documentation, and website copy.
**Discovery by regeneration**
Corrections arrived by the machine’s own subsequent runs, recorded as planned milestones. In early July 2026, a series of “core review” commits documented, in the project’s own words:
* announce-ID history “was unbounded per-slot growth” (`54cc8d601`);
* interface announce limiting could “leak a sustained flood” (`9d27af75c`);
* a “phantom-airtime leak” where frames “used to vanish silently” (`4ed75ffdd`);
* Group-packet deduplication “which RNS does not do” - a behaviour the reference never had,
implemented and later removed (`edd8e72be`);
* “both `unwrap_or(&[])` arms were unreachable dead defaults” (`74bea355e`);
* a benchmark crate “hasn’t compiled since” a prior rename, undetected for weeks because it
was outside the CI’s workspace (`86240b027`).
Earlier still: the record shows a “>1 MiB RNS-to-Prns interop stall” closed three weeks in
(`cc4d524a3`), and a known send-path hang shipped with the note “typed fast-fail a
candidate for later” (`a010e6613`).
**Laundered provenance**
The repository contains a committed commit-message hook (`.githooks/commit-msg`) that *blocks* any commit containing attribution for machine generation (“generated with claude/codex/copilot/cursor/gemini”, “co-authored-by”), with the explanation “The committer owns the commit”. The contributing guide is explicit: “AI tools … are welcome … what you submit is *yours*”, and describes the contributing population as “both human and automated contributors”. The fictitious “Prns Tests” identity completes the picture: A manufactured, unknowable contributor, used for marketing content.
**Authorship by assignment**
The human whose name is on the work cannot answer for it, because the choices were never made by a human, and only the general shape and constraints of the outward presentation was. Nothing in the project’s history shows an individual explaining a design decision, accepting a mistake in the first person, or going deeper under technical questioning; the record shows process language and marketing instead. Per the earlier mentioned test: any other person could have pressed the same button, and nothing would be different. The project is effectively unowned, and void of value.
By the criteria of [Assistance Versus Machine Substitution](#brandolinis-assistance-versus-substitution), this is substitution. The machine was the agent of the work; the “author” was a facade.
### The performance claims
The project’s central marketing claim - “up to 89× the throughput” of the reference - is also its most completely documented failure, because the project published the evidence of its own measurement. The apparatus, the results, and the problems are all on the record.
**The claim**
The README states “up to 89× the throughput”; the on-network marketing page repeats “up to 89× the throughput, 48× smaller peak-memory footprint, and 33× the energy efficiency of stock RNS 1.4.2”; the website’s front page carries the tagline “Measured, not just claimed”.
**The apparatus**
The reference is loaded through `benchmarks/reference/compiled_reference.py`, which installs `pyximport` and then asserts two things: that `RNS.compiled == True`, and that at least *one* RNS module was loaded from a native extension. The project’s own published “proof” records show exactly what those checks captured, on every platform:
```default
aarch64-apple-darwin: .../RNS.cpython-313-darwin.so, Cython 3.2.8, Python 3.13.13
x86_64-unknown-linux-gnu: .../RNS.cpython-313-x86_64-linux-gnu.so, gcc 11.4.0
x86_64-pc-windows-msvc: ~/.prns-oc/lib.win-amd64-cpython-313/RNS.cp313-win_amd64.pyd
```
In every case the recorded native module is the **top-level package only** - `RNS.so`, nothing below it. Nothing named `RNS.Transport`, `RNS.Destination`, `RNS.Packet`, `RNS.Link`, or `RNS.Resource` ever appears, because *nothing below the top level was ever compiled*. Nobody bothered to check or verify *anything* here.
The machine output was simply taken for truth, and a full marketing strategy was spun and produced on it. “RNS 1.4.2 (compiled)” - the label used in every table, chart, and marketing page - *is not a mode of RNS that exists*, but the hallucinations of a machine, which the humans created a marketing strategy on. In reality, it is the old `CRNS` development shim, whose top-level-only, debug-oriented “compilation” is slower than plain interpreted RNS, and which was *defunct for over a year* before these benchmarks were published.
**Interface choices**
The harness writes the reference’s configuration itself (`benchmarks/reference/participant_node.py`): `TCPClientInterface` for the initiator, `TCPServerInterface` for the responder and both relay sides, with `UDPInterface` as the abstract wire. The reference was never given its modern `BackboneInterface` on any platform, forcing the slowest possible interrfaces. The interface selection is never mentioned in any methodology text.
**The policy**
The published default-policy tables record the asymmetry directly: Prns at 500 Mbps / 128 KiB TCP policy against the reference at 10 Mbps / 8 KiB - slyly footnoted as “preserves each implementation’s normal TCP policy” (in the case of RNS, a conservative default policy that was selected to prioritize coexistence on slower, shared links, requiring the user to dial it up to full speed if they knew what they were doing). Raw transport “throughput” ratios of 20.65× (Linux) and 38.84× (Windows) are therefore mostly policy, not engine.
**The cross-host evidence**
The published results show the same scenario producing wildly different ratios by host, and the variance is entirely in the reference artifact:
| Host | Prns, single-packet | “Reference”, single-packet | Ratio |
|-------------------------|-----------------------|------------------------------|---------|
| macOS (Apple M4) | 37.4k/s | 420/s | 89.09× |
| Linux (i7-1260P) | 25.3k/s | 3.5k/s | 7.19× |
| Windows (Ryzen 5 5600X) | 30.8k/s | 3.9k/s | 8.00× |
Prns is consistent (25–37k/s). The reference artifact collapses to different depths on different hosts, and the single worst collapse - 420 packets per second on macOS - is the cell selected as the global headline. The “89×” is not a measure of Prns; it is a measure of how badly the broken baseline happened to fail on one host.
For reality calibration: Stock, interpreted RNS 1.5.4 on an ordinary mid-range laptop, single core, sustains roughly 30,000 single-packet deliveries per second (including ephemeral-key decryption), ~175,000–280,000 packets per second in transit relay, and on the order of 10 Gbps at 16 KiB payloads. The project’s “compiled” artifact measured 420–3,900 packets per second for its single-packet scenario: An order of magnitude or more *below* stock interpreted RNS. The comparison being marketed was not “Rust vs Python”; **it was “an implementation running under optimal conditions versus a mislabeled, broken shim on a slow legacy interface at a severe policy disadvantage”**.
**The equalized rows**
The project’s own “1 Gbps policy” rows, in which both sides are explicitly configured identically, publish ratios of roughly 2.4–8.4× across all hosts and scenarios - still against the broken baseline, but nowhere near 89×, and consistent with the ordinary, uncontroversial observation that a native implementation tends to outperform an interpreted one in raw throughput. That point needed no fudging to make, and is banal.
Interestingly, though, it seems that Prns is really only *marginally* faster than a Python implementation, running in interpreted mode, on a single CPU core.
**Assessment**
The front page says “Measured, not just claimed.” The record shows the opposite ordering: claimed, and arranged to look measured. No methodology section anywhere states what “compiled” means, that it is a deprecated development shim, that it builds debug targets, or which interface the reference was given; the one statement of the policy asymmetry appears in a footnote of the results tables themselves. If they did not need to fudge it, they would have published the method clearly.
### Overall Evaluation
Evaluated against the conditions of [Evaluating A Reticulum Implementation](#brandolinis-evaluating):
* **Provenance and attribution.** Fails: The fake “ground-up” origin story; zero reference links
on the website; a single well-hidden link in the README; a license file reading
`Copyright (c) 2026 The Prns Authors` over work directly generated from the licensed reference;
no original copyright or permission notice anywhere.
* **Agency and answerability.** Fails on every criterion of [Assistance Versus Machine Substitution](#brandolinis-assistance-versus-substitution):
Unauthored scope, uniform generation, discovery by regeneration, laundered provenance,
authorship by assignment.
* **Engineering.** Fails: The benchmark apparatus above; interop demonstrated only
against a pinned, outdated reference version over loopback while the marketing claims current
parity, interop failures with stock RNS; vendored prebuilt binaries and a republished fork
of an upstream crate (`nrf-softdevice 0.1.0-prns.1`) with no verifiable provenance;
committed WASM bundles.
* **Network behaviour.** Fails: Invented spectrum behaviour and compatibility claims
about third-party applications of the reference ecosystem (Sideband, NomadNet, MeshChat)
that are not established by any evidence.
* **Monetary and influence signals.** The marketing apparatus - website before protocol,
day-three twelve-language marketing, false benchmark headlines, “audited” and “formal proof”
claims - the conformal surface described in [Evaluating A Reticulum Implementation](#brandolinis-evaluating):
is where this project invested.
### Licensing Analysis
Applying the two legal layers established in [Copyright & The Two Legal Layers](#brandolinis-copyright-and-layers):
**Layer A - copyright infringement (license-independent)**
The record shows a direct copy roundtrip: the licensed reference implementation fed into a machine, transformed, at a scale and cadence no human could review, with a license file asserting a fresh copyright in the operator’s name and no acknowledgment of the work the project was generated from. No substantial, new human creative input is demonstrated anywhere in the record - the founding document explicitly frames the design as an instructed port of the reference’s contract. A primarily machine-generated copy of a copyrighted work, not accompanied by demonstrable substantial human creative input, is a derivative work over which the copier holds no copyright, and a reproduction of which without the original author’s permission infringes the original author’s copyright. This holds under any license, MIT included. The operator’s copyright claim over the result is, on this evidence, not merely unsubstantiated; it is the absence of one, directly asserted in the project’s own writing.
**Layer B - license conditions (Reticulum License specific)**
Modern Reticulum - the current wire format, the AES-256-based link encryption, ratchets, the cryptographic machinery as it exists today - has been published under the Reticulum License since April 15, 2025, effective from release 0.9.4 and every release since. As a derivative of that work, the license’s conditions attach: The copyright and permission notice must be included in all copies and substantial portions; the AI-training condition must be honoured; the harm condition must be honoured. The record shows none of the notice requirements met, and a production process that consists of the licensed work being ingested into a machine and regurgitated, at industrial scale and cadence.
**The cascading consequence**
Prns is distributed claiming dual MIT/Apache-2.0 licensing. It is, however, a direct derivative of Reticulum-licensed work, and the claimed grant is therefore void. Every downstream project that builds on Prns believing it is MIT/Apache-licensed is building on a grant that does not exist. The users of Prns, and all software developers using it, have in effect, been placed under conditions they were never told about. The “ground-up” claim is not merely false; it is the sole load-bearing element of an entire licensing posture, and it fails spectacularly.
### Consequences
The consequences of this pattern are examined in the following sections - the harm to users and to the network in [A Movement Of A Dozen](#brandolinis-movement-of-a-dozen), and the human dimension in [Network Health & Coexistence](#brandolinis-health-and-coexistence). This section’s contribution is narrower and intended as an instructive example: This is what a substitution project looks like, in full, on its own record. It is a reference example for [Evaluating A Reticulum Implementation](#brandolinis-evaluating), and it demonstrates, in one case, most of the elements this chapter describes.
### Verdict
Applying the three verdicts of [Evaluating A Reticulum Implementation](#brandolinis-evaluating), this project does not meet the standard. It is not “experimental but honest” - it is not labeled as experimental anywhere; the first thing users saw was a polished marketing presence promising a finished, tested, drop-in replacement. It is a project whose central claims are fabricated (the performance apparatus), whose provenance is laundered (the authorship machinery), whose foundation is misrepresented (the “ground-up” story), whose core semantics were learned late and by regeneration, and whose operator cannot possibly answer for any of it. It is also a blatant copyright violation of the reference implementation.
The proposed conclusion, for users and for the network: Treat the Prns project as hostile regardless of its polished surface, and as a hazard insofar as it invites users onto shared networks. Nothing in this section is a judgment about the people involved; it is a reading of the results produced, their history and how they came to be, which in the regrettable lack of any human authorship is the only thing that can be expected to be held to account.
### Dating
This examination reflects the publicly available material as of September 2026; the repository in question continued to receive commits at the time of writing, so readers should treat citations to commits and files as point-in-time evidence. A [forensics snapshot](https://github.com/markqvist/forensics_prns) is publicly available on GitHub.
## The Movement Of A Dozen
### Presentation, Elongated
@ -1131,4 +909,226 @@ A lot of us rely on these networks every day. They carry our messages, our coord
They are valuable, free, and very hard to shut down. The response is not to become aggressive. It is to be *more* of what the network already is: Real, open, owned, and shared.
*Mark*
*Mark*
## Addendum A: The Prns Case
### Purpose & Scope
This section provides a concrete example, which future evaluations can use as a template. Its purpose is not to be the last word on this particular subject, but to be an example of how the ideas in this chapter can be applied, and to make the next such examination easier.
The subject of this case study is **Prns**, a project published at the repository `github.com/KenAKAFrosty/Prns`, presented as a “ground-up implementation of Reticulum, written in Rust”, marketed as faster, safer, and more strictly tested than the reference, and widely promoted with the claim of “up to 89× the throughput” of the reference implementation. The record described below is the project’s own, and sourced from its GitHub repository, analyzed locally.
### The Project In Brief
* **Time span.** 3,374 commits between 2026-05-26 and 2026-09-12: approximately 110 days,
at a mean rate of ~31 commits per day. Monthly: 132 / 1,137 / 1,097 / 805 / 203.
* **Authorship.** 3,252 of 3,374 commits (96.4%) are authored by a single account. A
second identity, “Prns Tests [tests@example.test](mailto:tests@example.test)” - a fictitious identity on a reserved
domain - contributed 35 commits, every one of them website and marketing content.
* **Size.** 3,519 tracked files; 1,983 Rust files; 636,226 lines of Rust; approximately
22.7 MB of Rust source; 69.5 MB of total repository content.
* **Scope claimed.** A daemon (“drop-in replacement” for the reference daemon), embedded
firmware for three microcontroller families (including six ESP32-S3 board variants and
nRF52840), SDKs and bindings for nine languages, a browser-based node and web flasher, a
twelve-language website, a benchmark apparatus with its own publication and “proof”
pipeline, and a validation hub with oracles, fuzzing, mutation testing, and formal-proof
claims.
* **Marketing claims.** “Ground-up implementation of Reticulum”; “up to 89× the
throughput”; “48× smaller peak-memory footprint”; “33× the energy efficiency”;
“Measured, not just claimed”; “Enforced, then audited”; “byte-for-byte wire parity with
the reference implementation”; “works with Sideband, NomadNet, MeshChat, etc.”;
“no_std (no alloc required either)”.
* **Status at the time of writing.** Version 0.3.7; published version history begins at
0.3.0. The repository continues to receive commits.
### Question 1: Is this a clean implementation, or was it directly generated from the reference?
The first of the two deciding questions from [Evaluating A Reticulum Implementation](#brandolinis-evaluating) is settled by the project’s own record. An actual [clean-room](#brandolinis-cleanroom-delusion) implementation, reasoned out and written by humans, would owe nothing to any license. The data available shows clearly that Prns is not that.
* **The founding state.** The first commit, “Scaffold Personal Reticulum suite”, contains
the scaffolding of not one but two ports - `personal-rns` and `personal-lxmf`, the latter
being the reference’s companion messaging protocol - together with a daemon scaffold and
a 233-line founding document, `docs/build-ethos.md`. That document declares the project’s
goal as a “performance-focused drop-in-replacement for rnsd” and its governing principle
as: “Port the contract, not the implementation.” It further states directly to the
machine-loop, that **“You owe the reference fidelity at exactly two boundaries:
The wire… The behavior. … Between those two boundaries, the model is yours”**.
At this point, the very first commit, effectively the whole of the implementation design
and any relevant decisions are handed over to the LLM.
* **Continuous ingestion from the reference.** 506 commits reference RNS or Reticulum
source behaviour; the word “parity” appears in 49 commit messages. Commits cite the reference
implementation’s own source locations (for example `Transport.py:1367`) when correcting
their own divergences and mistakes.
* **Byte-level fidelity as an explicit goal.** Within 48 hours of the first commit, the
record shows a “crypto adapter - vetted primitives, byte-exact vs RNS 1.3.1”, and a wire
implementation matching the reference’s packet header layout. The project’s own
validation apparatus decodes wire vectors using the reference implementation’s own
packet parser, and the interop suite consists of real, stock-RNS peer nodes - that is,
the reference source itself, used as the ground truth against which this LLM output is
checked, and committed as accepted and verified after 48 hours of the project’s recorded start.
* **The marketing mismatch.** The same record that documents all of the above describes the
project, publicly, as “a ground-up implementation of Reticulum” - while declining, on its
website, to link to the reference implementation at all: the entire tree mentions the
reference’s author in six files, and the website in none.
Conclusion: the project’s own history and commit record establishes that it was generated directly from the reference implementation’s source code, not reasoned out from the public-domain protocol. It is a derivative of licensed work within the meaning of [the Reticulum License](#brandolinis-what-the-license-is) and [general copyright law](#brandolinis-copyright-and-layers). The “ground-up” claim, which carries its entire legal and marketing posture, is disproven by the project’s own history.
### Question 2: Who, or what, is the agent of the work?
The second deciding question is answered by the application of [Assistance Versus Machine Substitution](#brandolinis-assistance-versus-substitution) criteria to the project.
**Scope that no human could have authored**
636,226 lines of Rust in 110 days is approximately 5,800 lines per day, every day, including weekends - with 149 commits recorded between midnight and 06:00, and Saturday the single busiest weekday. No human review or decision capacity is commensurable with this volume; the review capacity and the output volume are structurally incommensurable, which is the definition of unauthored scope.
**Uniform generation**
The record shows no sign of human development, growth, or learning: No contested decisions, no style drift. Instead: endless renaming (in the first 48 hours: `State → EngineState → TickInput → TickOutput`), uniform fluent register in every commit, and the exact same, synthetic voice in code, documentation, and website copy.
**Discovery by regeneration**
Corrections arrived by the machine’s own subsequent runs, recorded as planned milestones. In early July 2026, a series of “core review” commits documented, in the project’s own words:
* announce-ID history “was unbounded per-slot growth” (`54cc8d601`);
* interface announce limiting could “leak a sustained flood” (`9d27af75c`);
* a “phantom-airtime leak” where frames “used to vanish silently” (`4ed75ffdd`);
* Group-packet deduplication “which RNS does not do” - a behaviour the reference never had,
implemented and later removed (`edd8e72be`);
* “both `unwrap_or(&[])` arms were unreachable dead defaults” (`74bea355e`);
* a benchmark crate “hasn’t compiled since” a prior rename, undetected for weeks because it
was outside the CI’s workspace (`86240b027`).
Earlier still: the record shows a “>1 MiB RNS-to-Prns interop stall” closed three weeks in
(`cc4d524a3`), and a known send-path hang shipped with the note “typed fast-fail a
candidate for later” (`a010e6613`).
**Laundered provenance**
The repository contains a committed commit-message hook (`.githooks/commit-msg`) that *blocks* any commit containing attribution for machine generation (“generated with claude/codex/copilot/cursor/gemini”, “co-authored-by”), with the explanation “The committer owns the commit”. The contributing guide is explicit: “AI tools … are welcome … what you submit is *yours*”, and describes the contributing population as “both human and automated contributors”. The fictitious “Prns Tests” identity completes the picture: A manufactured, unknowable contributor, used for marketing content.
**Authorship by assignment**
The human whose name is on the work cannot answer for it, because the choices were never made by a human, and only the general shape and constraints of the outward presentation was. Nothing in the project’s history shows an individual explaining a design decision, accepting a mistake in the first person, or going deeper under technical questioning; the record shows process language and marketing instead. Per the earlier mentioned test: any other person could have pressed the same button, and nothing would be different. The project is effectively unowned, and void of value.
By the criteria of [Assistance Versus Machine Substitution](#brandolinis-assistance-versus-substitution), this is substitution. The machine was the agent of the work; the “author” was a facade.
### The performance claims
The project’s central marketing claim - “up to 89× the throughput” of the reference - is also its most completely documented failure, because the project published the evidence of its own measurement. The apparatus, the results, and the problems are all on the record.
**The claim**
The README states “up to 89× the throughput”; the on-network marketing page repeats “up to 89× the throughput, 48× smaller peak-memory footprint, and 33× the energy efficiency of stock RNS 1.4.2”; the website’s front page carries the tagline “Measured, not just claimed”.
**The apparatus**
The reference is loaded through `benchmarks/reference/compiled_reference.py`, which installs `pyximport` and then asserts two things: that `RNS.compiled == True`, and that at least *one* RNS module was loaded from a native extension. The project’s own published “proof” records show exactly what those checks captured, on every platform:
```default
aarch64-apple-darwin: .../RNS.cpython-313-darwin.so, Cython 3.2.8, Python 3.13.13
x86_64-unknown-linux-gnu: .../RNS.cpython-313-x86_64-linux-gnu.so, gcc 11.4.0
x86_64-pc-windows-msvc: ~/.prns-oc/lib.win-amd64-cpython-313/RNS.cp313-win_amd64.pyd
```
In every case the recorded native module is the **top-level package only** - `RNS.so`, nothing below it. Nothing named `RNS.Transport`, `RNS.Destination`, `RNS.Packet`, `RNS.Link`, or `RNS.Resource` ever appears, because *nothing below the top level was ever compiled*. Nobody bothered to check or verify *anything* here.
The machine output was simply taken for truth, and a full marketing strategy was spun and produced on it. “RNS 1.4.2 (compiled)” - the label used in every table, chart, and marketing page - *is not a mode of RNS that exists*, but the hallucinations of a machine, which the humans created a marketing strategy on. In reality, it is the old `CRNS` development shim, whose top-level-only, debug-oriented “compilation” is slower than plain interpreted RNS, and which was *defunct for over a year* before these benchmarks were published.
**Interface choices**
The harness writes the reference’s configuration itself (`benchmarks/reference/participant_node.py`): `TCPClientInterface` for the initiator, `TCPServerInterface` for the responder and both relay sides, with `UDPInterface` as the abstract wire. The reference was never given its modern `BackboneInterface` on any platform, forcing the slowest possible interrfaces. The interface selection is never mentioned in any methodology text.
**The policy**
The published default-policy tables record the asymmetry directly: Prns at 500 Mbps / 128 KiB TCP policy against the reference at 10 Mbps / 8 KiB - slyly footnoted as “preserves each implementation’s normal TCP policy” (in the case of RNS, a conservative default policy that was selected to prioritize coexistence on slower, shared links, requiring the user to dial it up to full speed if they knew what they were doing). Raw transport “throughput” ratios of 20.65× (Linux) and 38.84× (Windows) are therefore mostly policy, not engine.
**The cross-host evidence**
The published results show the same scenario producing wildly different ratios by host, and the variance is entirely in the reference artifact:
| Host | Prns, single-packet | “Reference”, single-packet | Ratio |
|-------------------------|-----------------------|------------------------------|---------|
| macOS (Apple M4) | 37.4k/s | 420/s | 89.09× |
| Linux (i7-1260P) | 25.3k/s | 3.5k/s | 7.19× |
| Windows (Ryzen 5 5600X) | 30.8k/s | 3.9k/s | 8.00× |
Prns is consistent (25–37k/s). The reference artifact collapses to different depths on different hosts, and the single worst collapse - 420 packets per second on macOS - is the cell selected as the global headline. The “89×” is not a measure of Prns; it is a measure of how badly the broken baseline happened to fail on one host.
For reality calibration: Stock, interpreted RNS 1.5.4 on an ordinary mid-range laptop, single core, sustains roughly 30,000 single-packet deliveries per second (including ephemeral-key decryption), ~175,000–280,000 packets per second in transit relay, and on the order of 10 Gbps at 16 KiB payloads. The project’s “compiled” artifact measured 420–3,900 packets per second for its single-packet scenario: An order of magnitude or more *below* stock interpreted RNS. The comparison being marketed was not “Rust vs Python”; **it was “an implementation running under optimal conditions versus a mislabeled, broken shim on a slow legacy interface at a severe policy disadvantage”**.
**The equalized rows**
The project’s own “1 Gbps policy” rows, in which both sides are explicitly configured identically, publish ratios of roughly 2.4–8.4× across all hosts and scenarios - still against the broken baseline, but nowhere near 89×, and consistent with the ordinary, uncontroversial observation that a native implementation tends to outperform an interpreted one in raw throughput. That point needed no fudging to make, and is banal.
Interestingly, though, it seems that Prns is really only *marginally* faster than a Python implementation, running in interpreted mode, on a single CPU core.
**Assessment**
The front page says “Measured, not just claimed.” The record shows the opposite ordering: claimed, and arranged to look measured. No methodology section anywhere states what “compiled” means, that it is a deprecated development shim, that it builds debug targets, or which interface the reference was given; the one statement of the policy asymmetry appears in a footnote of the results tables themselves. If they did not need to fudge it, they would have published the method clearly.
### Overall Evaluation
Evaluated against the conditions of [Evaluating A Reticulum Implementation](#brandolinis-evaluating):
* **Provenance and attribution.** Fails: The fake “ground-up” origin story; zero reference links
on the website; a single well-hidden link in the README; a license file reading
`Copyright (c) 2026 The Prns Authors` over work directly generated from the licensed reference;
no original copyright or permission notice anywhere.
* **Agency and answerability.** Fails on every criterion of [Assistance Versus Machine Substitution](#brandolinis-assistance-versus-substitution):
Unauthored scope, uniform generation, discovery by regeneration, laundered provenance,
authorship by assignment.
* **Engineering.** Fails: The benchmark apparatus above; interop demonstrated only
against a pinned, outdated reference version over loopback while the marketing claims current
parity, interop failures with stock RNS; vendored prebuilt binaries and a republished fork
of an upstream crate (`nrf-softdevice 0.1.0-prns.1`) with no verifiable provenance;
committed WASM bundles.
* **Network behaviour.** Fails: Invented spectrum behaviour and compatibility claims
about third-party applications of the reference ecosystem (Sideband, NomadNet, MeshChat)
that are not established by any evidence.
* **Monetary and influence signals.** The marketing apparatus - website before protocol,
day-three twelve-language marketing, false benchmark headlines, “audited” and “formal proof”
claims - the conformal surface described in [Evaluating A Reticulum Implementation](#brandolinis-evaluating):
is where this project invested.
### Licensing Analysis
Applying the two legal layers established in [Copyright & The Two Legal Layers](#brandolinis-copyright-and-layers):
**Layer A - copyright infringement (license-independent)**
The record shows a direct copy roundtrip: the licensed reference implementation fed into a machine, transformed, at a scale and cadence no human could review, with a license file asserting a fresh copyright in the operator’s name and no acknowledgment of the work the project was generated from. No substantial, new human creative input is demonstrated anywhere in the record - the founding document explicitly frames the design as an instructed port of the reference’s contract. A primarily machine-generated copy of a copyrighted work, not accompanied by demonstrable substantial human creative input, is a derivative work over which the copier holds no copyright, and a reproduction of which without the original author’s permission infringes the original author’s copyright. This holds under any license, MIT included. The operator’s copyright claim over the result is, on this evidence, not merely unsubstantiated; it is the absence of one, directly asserted in the project’s own writing.
**Layer B - license conditions (Reticulum License specific)**
Modern Reticulum - the current wire format, the AES-256-based link encryption, ratchets, the cryptographic machinery as it exists today - has been published under the Reticulum License since April 15, 2025, effective from release 0.9.4 and every release since. As a derivative of that work, the license’s conditions attach: The copyright and permission notice must be included in all copies and substantial portions; the AI-training condition must be honoured; the harm condition must be honoured. The record shows none of the notice requirements met, and a production process that consists of the licensed work being ingested into a machine and regurgitated, at industrial scale and cadence.
**The cascading consequence**
Prns is distributed claiming dual MIT/Apache-2.0 licensing. It is, however, a direct derivative of Reticulum-licensed work, and the claimed grant is therefore void. Every downstream project that builds on Prns believing it is MIT/Apache-licensed is building on a grant that does not exist. The users of Prns, and all software developers using it, have in effect, been placed under conditions they were never told about. The “ground-up” claim is not merely false; it is the sole load-bearing element of an entire licensing posture, and it fails spectacularly.
### Consequences
The consequences of this pattern are examined in the following sections: The harm to users and to the network in [A Movement Of A Dozen](#brandolinis-movement-of-a-dozen), and the human dimension in [Network Health & Coexistence](#brandolinis-health-and-coexistence). The contribution of this addendum is narrower and intended as an instructive example: This is what a substitution project looks like, in full, on its own record. It is a reference example for [Evaluating A Reticulum Implementation](#brandolinis-evaluating), and it demonstrates, in one case, most of the elements this chapter describes.
### Verdict
Applying the three verdicts of [Evaluating A Reticulum Implementation](#brandolinis-evaluating), this project does not meet the standard. It is not “experimental but honest” - it is not labeled as experimental anywhere; the first thing users saw was a polished marketing presence promising a finished, tested, drop-in replacement. It is a project whose central claims are fabricated (the performance apparatus), whose provenance is laundered (the authorship machinery), whose foundation is misrepresented (the “ground-up” story), whose core semantics were learned late and by regeneration, and whose operator cannot possibly answer for any of it. It is also a blatant copyright violation of the reference implementation.
The proposed conclusion, for users and for the network: Treat the Prns project as hostile regardless of its polished surface, and as a hazard insofar as it invites users onto shared networks. Nothing in this section is a judgment about the people involved; it is a reading of the results produced, their history and how they came to be, which in the regrettable lack of any human authorship is the only thing that can be expected to be held to account.
### Dating
This examination reflects the publicly available material as of September 2026; the repository in question continued to receive commits at the time of writing, so readers should treat citations to commits and files as point-in-time evidence. A [forensics snapshot](https://github.com/markqvist/forensics_prns) is publicly available on GitHub.

22
docs/markdown/index.md
View file

@ -302,17 +302,6 @@ to participate in the development of Reticulum itself.
* [The Conformal Surface](brandolinis.md#the-conformal-surface)
* [Possible Verdicts](brandolinis.md#possible-verdicts)
* [These Standards Are Reasonable](brandolinis.md#these-standards-are-reasonable)
* [The Prns Case](brandolinis.md#the-prns-case)
* [Purpose & Scope](brandolinis.md#purpose-scope)
* [The Project In Brief](brandolinis.md#the-project-in-brief)
* [Question 1: Is this a clean implementation, or was it directly generated from the reference?](brandolinis.md#question-1-is-this-a-clean-implementation-or-was-it-directly-generated-from-the-reference)
* [Question 2: Who, or what, is the agent of the work?](brandolinis.md#question-2-who-or-what-is-the-agent-of-the-work)
* [The performance claims](brandolinis.md#the-performance-claims)
* [Overall Evaluation](brandolinis.md#overall-evaluation)
* [Licensing Analysis](brandolinis.md#licensing-analysis)
* [Consequences](brandolinis.md#consequences)
* [Verdict](brandolinis.md#verdict)
* [Dating](brandolinis.md#dating)
* [The Movement Of A Dozen](brandolinis.md#the-movement-of-a-dozen)
* [Presentation, Elongated](brandolinis.md#presentation-elongated)
* [Headcount](brandolinis.md#headcount)
@ -330,6 +319,17 @@ to participate in the development of Reticulum itself.
* [The Place Of New Implementations](brandolinis.md#the-place-of-new-implementations)
* [Expanding The Commons](brandolinis.md#expanding-the-commons)
* [Defence Of The Commons](brandolinis.md#defence-of-the-commons)
* [Addendum A: The Prns Case](brandolinis.md#addendum-a-the-prns-case)
* [Purpose & Scope](brandolinis.md#purpose-scope)
* [The Project In Brief](brandolinis.md#the-project-in-brief)
* [Question 1: Is this a clean implementation, or was it directly generated from the reference?](brandolinis.md#question-1-is-this-a-clean-implementation-or-was-it-directly-generated-from-the-reference)
* [Question 2: Who, or what, is the agent of the work?](brandolinis.md#question-2-who-or-what-is-the-agent-of-the-work)
* [The performance claims](brandolinis.md#the-performance-claims)
* [Overall Evaluation](brandolinis.md#overall-evaluation)
* [Licensing Analysis](brandolinis.md#licensing-analysis)
* [Consequences](brandolinis.md#consequences)
* [Verdict](brandolinis.md#verdict)
* [Dating](brandolinis.md#dating)
* [API Reference](reference.md)
* [`Reticulum`](reference.md#RNS.Reticulum)

516
docs/source/brandolinis.rst
View file

@ -732,263 +732,6 @@ I'll close this guide by stating what these standards are *not*\ : They are neit
The reference implementation has met this standard for years, and its users know what that looks like.
.. _brandolinis-prns:
The Prns Case
-------------
.. _brandolinis-purpose-and-scope:
Purpose & Scope
^^^^^^^^^^^^^^^
This section provides a concrete example, which future evaluations can use as a template. Its purpose is not to be the last word on this particular subject, but to be an example of how the ideas in this chapter can be applied, and to make the next such examination easier.
The subject of this case study is **Prns**\ , a project published at the repository ``github.com/KenAKAFrosty/Prns``\ , presented as a "ground-up implementation of Reticulum, written in Rust", marketed as faster, safer, and more strictly tested than the reference, and widely promoted with the claim of "up to 89× the throughput" of the reference implementation. The record described below is the project's own, and sourced from its GitHub repository, analyzed locally.
.. _brandolinis-project-in-brief:
The Project In Brief
^^^^^^^^^^^^^^^^^^^^
* **Time span.** 3,374 commits between 2026-05-26 and 2026-09-12: approximately 110 days,
at a mean rate of ~31 commits per day. Monthly: 132 / 1,137 / 1,097 / 805 / 203.
* **Authorship.** 3,252 of 3,374 commits (96.4%) are authored by a single account. A
second identity, "Prns Tests tests@example.test" - a fictitious identity on a reserved
domain - contributed 35 commits, every one of them website and marketing content.
* **Size.** 3,519 tracked files; 1,983 Rust files; 636,226 lines of Rust; approximately
22.7 MB of Rust source; 69.5 MB of total repository content.
* **Scope claimed.** A daemon ("drop-in replacement" for the reference daemon), embedded
firmware for three microcontroller families (including six ESP32-S3 board variants and
nRF52840), SDKs and bindings for nine languages, a browser-based node and web flasher, a
twelve-language website, a benchmark apparatus with its own publication and "proof"
pipeline, and a validation hub with oracles, fuzzing, mutation testing, and formal-proof
claims.
* **Marketing claims.** "Ground-up implementation of Reticulum"; "up to 89× the
throughput"; "48× smaller peak-memory footprint"; "33× the energy efficiency";
"Measured, not just claimed"; "Enforced, then audited"; "byte-for-byte wire parity with
the reference implementation"; "works with Sideband, NomadNet, MeshChat, etc.";
"no_std (no alloc required either)".
* **Status at the time of writing.** Version 0.3.7; published version history begins at
0.3.0. The repository continues to receive commits.
.. _brandolinis-prns-question-1:
Question 1: Is this a clean implementation, or was it directly generated from the reference?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The first of the two deciding questions from :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>` is settled by the project's own record. An actual :ref:`clean-room<brandolinis-cleanroom-delusion>` implementation, reasoned out and written by humans, would owe nothing to any license. The data available shows clearly that Prns is not that.
* **The founding state.** The first commit, "Scaffold Personal Reticulum suite", contains
the scaffolding of not one but two ports - ``personal-rns`` and ``personal-lxmf``\ , the latter
being the reference's companion messaging protocol - together with a daemon scaffold and
a 233-line founding document, ``docs/build-ethos.md``. That document declares the project's
goal as a "performance-focused drop-in-replacement for rnsd" and its governing principle
as: "Port the contract, not the implementation." It further states directly to the
machine-loop, that **"You owe the reference fidelity at exactly two boundaries:
The wire... The behavior. ... Between those two boundaries, the model is yours"**.
At this point, the very first commit, effectively the whole of the implementation design
and any relevant decisions are handed over to the LLM.
* **Continuous ingestion from the reference.** 506 commits reference RNS or Reticulum
source behaviour; the word "parity" appears in 49 commit messages. Commits cite the reference
implementation's own source locations (for example ``Transport.py:1367``) when correcting
their own divergences and mistakes.
* **Byte-level fidelity as an explicit goal.** Within 48 hours of the first commit, the
record shows a "crypto adapter - vetted primitives, byte-exact vs RNS 1.3.1", and a wire
implementation matching the reference's packet header layout. The project's own
validation apparatus decodes wire vectors using the reference implementation's own
packet parser, and the interop suite consists of real, stock-RNS peer nodes - that is,
the reference source itself, used as the ground truth against which this LLM output is
checked, and committed as accepted and verified after 48 hours of the project's recorded start.
* **The marketing mismatch.** The same record that documents all of the above describes the
project, publicly, as "a ground-up implementation of Reticulum" - while declining, on its
website, to link to the reference implementation at all: the entire tree mentions the
reference's author in six files, and the website in none.
Conclusion: the project's own history and commit record establishes that it was generated directly from the reference implementation's source code, not reasoned out from the public-domain protocol. It is a derivative of licensed work within the meaning of :ref:`the Reticulum License<brandolinis-what-the-license-is>` and :ref:`general copyright law<brandolinis-copyright-and-layers>`. The "ground-up" claim, which carries its entire legal and marketing posture, is disproven by the project's own history.
.. _brandolinis-prns-question-2:
Question 2: Who, or what, is the agent of the work?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The second deciding question is answered by the application of :ref:`Assistance Versus Machine Substitution<brandolinis-assistance-versus-substitution>` criteria to the project.
**Scope that no human could have authored**
636,226 lines of Rust in 110 days is approximately 5,800 lines per day, every day, including weekends - with 149 commits recorded between midnight and 06:00, and Saturday the single busiest weekday. No human review or decision capacity is commensurable with this volume; the review capacity and the output volume are structurally incommensurable, which is the definition of unauthored scope.
**Uniform generation**
The record shows no sign of human development, growth, or learning: No contested decisions, no style drift. Instead: endless renaming (in the first 48 hours: ``State → EngineState → TickInput → TickOutput``\ ), uniform fluent register in every commit, and the exact same, synthetic voice in code, documentation, and website copy.
**Discovery by regeneration**
Corrections arrived by the machine's own subsequent runs, recorded as planned milestones. In early July 2026, a series of "core review" commits documented, in the project's own words:
* announce-ID history "was unbounded per-slot growth" (\ ``54cc8d601``\ );
* interface announce limiting could "leak a sustained flood" (\ ``9d27af75c``\ );
* a "phantom-airtime leak" where frames "used to vanish silently" (\ ``4ed75ffdd``\ );
* Group-packet deduplication "which RNS does not do" - a behaviour the reference never had,
implemented and later removed (\ ``edd8e72be``\ );
* "both ``unwrap_or(&[])`` arms were unreachable dead defaults" (\ ``74bea355e``\ );
* a benchmark crate "hasn't compiled since" a prior rename, undetected for weeks because it
was outside the CI's workspace (\ ``86240b027``\ ).
Earlier still: the record shows a ">1 MiB RNS-to-Prns interop stall" closed three weeks in
(\ ``cc4d524a3``\ ), and a known send-path hang shipped with the note "typed fast-fail a
candidate for later" (\ ``a010e6613``\ ).
**Laundered provenance**
The repository contains a committed commit-message hook (\ ``.githooks/commit-msg``\ ) that *blocks* any commit containing attribution for machine generation ("generated with claude/codex/copilot/cursor/gemini", "co-authored-by"), with the explanation "The committer owns the commit". The contributing guide is explicit: "AI tools ... are welcome ... what you submit is *yours*", and describes the contributing population as "both human and automated contributors". The fictitious "Prns Tests" identity completes the picture: A manufactured, unknowable contributor, used for marketing content.
**Authorship by assignment**
The human whose name is on the work cannot answer for it, because the choices were never made by a human, and only the general shape and constraints of the outward presentation was. Nothing in the project's history shows an individual explaining a design decision, accepting a mistake in the first person, or going deeper under technical questioning; the record shows process language and marketing instead. Per the earlier mentioned test: any other person could have pressed the same button, and nothing would be different. The project is effectively unowned, and void of value.
By the criteria of :ref:`Assistance Versus Machine Substitution<brandolinis-assistance-versus-substitution>`, this is substitution. The machine was the agent of the work; the "author" was a facade.
.. _brandolinis-prns-performance:
The performance claims
^^^^^^^^^^^^^^^^^^^^^^
The project's central marketing claim - "up to 89× the throughput" of the reference - is also its most completely documented failure, because the project published the evidence of its own measurement. The apparatus, the results, and the problems are all on the record.
**The claim**
The README states "up to 89× the throughput"; the on-network marketing page repeats "up to 89× the throughput, 48× smaller peak-memory footprint, and 33× the energy efficiency of stock RNS 1.4.2"; the website's front page carries the tagline "Measured, not just claimed".
**The apparatus**
The reference is loaded through ``benchmarks/reference/compiled_reference.py``\ , which installs ``pyximport`` and then asserts two things: that ``RNS.compiled == True``\ , and that at least *one* RNS module was loaded from a native extension. The project's own published "proof" records show exactly what those checks captured, on every platform:
.. code-block::
aarch64-apple-darwin: .../RNS.cpython-313-darwin.so, Cython 3.2.8, Python 3.13.13
x86_64-unknown-linux-gnu: .../RNS.cpython-313-x86_64-linux-gnu.so, gcc 11.4.0
x86_64-pc-windows-msvc: ~/.prns-oc/lib.win-amd64-cpython-313/RNS.cp313-win_amd64.pyd
In every case the recorded native module is the **top-level package only** - ``RNS.so``\ , nothing below it. Nothing named ``RNS.Transport``\ , ``RNS.Destination``\ , ``RNS.Packet``\ , ``RNS.Link``\ , or ``RNS.Resource`` ever appears, because *nothing below the top level was ever compiled*. Nobody bothered to check or verify *anything* here.
The machine output was simply taken for truth, and a full marketing strategy was spun and produced on it. "RNS 1.4.2 (compiled)" - the label used in every table, chart, and marketing page - *is not a mode of RNS that exists*, but the hallucinations of a machine, which the humans created a marketing strategy on. In reality, it is the old ``CRNS`` development shim, whose top-level-only, debug-oriented "compilation" is slower than plain interpreted RNS, and which was *defunct for over a year* before these benchmarks were published.
**Interface choices**
The harness writes the reference's configuration itself (\ ``benchmarks/reference/participant_node.py``\ ): ``TCPClientInterface`` for the initiator, ``TCPServerInterface`` for the responder and both relay sides, with ``UDPInterface`` as the abstract wire. The reference was never given its modern ``BackboneInterface`` on any platform, forcing the slowest possible interrfaces. The interface selection is never mentioned in any methodology text.
**The policy**
The published default-policy tables record the asymmetry directly: Prns at 500 Mbps / 128 KiB TCP policy against the reference at 10 Mbps / 8 KiB - slyly footnoted as "preserves each implementation's normal TCP policy" (in the case of RNS, a conservative default policy that was selected to prioritize coexistence on slower, shared links, requiring the user to dial it up to full speed if they knew what they were doing). Raw transport "throughput" ratios of 20.65× (Linux) and 38.84× (Windows) are therefore mostly policy, not engine.
**The cross-host evidence**
The published results show the same scenario producing wildly different ratios by host, and the variance is entirely in the reference artifact:
.. list-table::
:header-rows: 1
* - Host
- Prns, single-packet
- "Reference", single-packet
- Ratio
* - macOS (Apple M4)
- 37.4k/s
- 420/s
- 89.09×
* - Linux (i7-1260P)
- 25.3k/s
- 3.5k/s
- 7.19×
* - Windows (Ryzen 5 5600X)
- 30.8k/s
- 3.9k/s
- 8.00×
Prns is consistent (25–37k/s). The reference artifact collapses to different depths on different hosts, and the single worst collapse - 420 packets per second on macOS - is the cell selected as the global headline. The "89×" is not a measure of Prns; it is a measure of how badly the broken baseline happened to fail on one host.
For reality calibration: Stock, interpreted RNS 1.5.4 on an ordinary mid-range laptop, single core, sustains roughly 30,000 single-packet deliveries per second (including ephemeral-key decryption), ~175,000–280,000 packets per second in transit relay, and on the order of 10 Gbps at 16 KiB payloads. The project's "compiled" artifact measured 420–3,900 packets per second for its single-packet scenario: An order of magnitude or more *below* stock interpreted RNS. The comparison being marketed was not "Rust vs Python"; **it was "an implementation running under optimal conditions versus a mislabeled, broken shim on a slow legacy interface at a severe policy disadvantage"**.
**The equalized rows**
The project's own "1 Gbps policy" rows, in which both sides are explicitly configured identically, publish ratios of roughly 2.4–8.4× across all hosts and scenarios - still against the broken baseline, but nowhere near 89×, and consistent with the ordinary, uncontroversial observation that a native implementation tends to outperform an interpreted one in raw throughput. That point needed no fudging to make, and is banal.
Interestingly, though, it seems that Prns is really only *marginally* faster than a Python implementation, running in interpreted mode, on a single CPU core.
**Assessment**
The front page says "Measured, not just claimed." The record shows the opposite ordering: claimed, and arranged to look measured. No methodology section anywhere states what "compiled" means, that it is a deprecated development shim, that it builds debug targets, or which interface the reference was given; the one statement of the policy asymmetry appears in a footnote of the results tables themselves. If they did not need to fudge it, they would have published the method clearly.
.. _brandolinis-prns-overall:
Overall Evaluation
^^^^^^^^^^^^^^^^^^
Evaluated against the conditions of :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`:
* **Provenance and attribution.** Fails: The fake "ground-up" origin story; zero reference links
on the website; a single well-hidden link in the README; a license file reading
``Copyright (c) 2026 The Prns Authors`` over work directly generated from the licensed reference;
no original copyright or permission notice anywhere.
* **Agency and answerability.** Fails on every criterion of :ref:`Assistance Versus Machine Substitution<brandolinis-assistance-versus-substitution>`:
Unauthored scope, uniform generation, discovery by regeneration, laundered provenance,
authorship by assignment.
* **Engineering.** Fails: The benchmark apparatus above; interop demonstrated only
against a pinned, outdated reference version over loopback while the marketing claims current
parity, interop failures with stock RNS; vendored prebuilt binaries and a republished fork
of an upstream crate (``nrf-softdevice 0.1.0-prns.1``) with no verifiable provenance;
committed WASM bundles.
* **Network behaviour.** Fails: Invented spectrum behaviour and compatibility claims
about third-party applications of the reference ecosystem (Sideband, NomadNet, MeshChat)
that are not established by any evidence.
* **Monetary and influence signals.** The marketing apparatus - website before protocol,
day-three twelve-language marketing, false benchmark headlines, "audited" and "formal proof"
claims - the conformal surface described in :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`:
is where this project invested.
.. _brandolinis-prns-licensing:
Licensing Analysis
^^^^^^^^^^^^^^^^^^
Applying the two legal layers established in :ref:`Copyright & The Two Legal Layers<brandolinis-copyright-and-layers>`:
**Layer A - copyright infringement (license-independent)**
The record shows a direct copy roundtrip: the licensed reference implementation fed into a machine, transformed, at a scale and cadence no human could review, with a license file asserting a fresh copyright in the operator's name and no acknowledgment of the work the project was generated from. No substantial, new human creative input is demonstrated anywhere in the record - the founding document explicitly frames the design as an instructed port of the reference's contract. A primarily machine-generated copy of a copyrighted work, not accompanied by demonstrable substantial human creative input, is a derivative work over which the copier holds no copyright, and a reproduction of which without the original author's permission infringes the original author's copyright. This holds under any license, MIT included. The operator's copyright claim over the result is, on this evidence, not merely unsubstantiated; it is the absence of one, directly asserted in the project's own writing.
**Layer B - license conditions (Reticulum License specific)**
Modern Reticulum - the current wire format, the AES-256-based link encryption, ratchets, the cryptographic machinery as it exists today - has been published under the Reticulum License since April 15, 2025, effective from release 0.9.4 and every release since. As a derivative of that work, the license's conditions attach: The copyright and permission notice must be included in all copies and substantial portions; the AI-training condition must be honoured; the harm condition must be honoured. The record shows none of the notice requirements met, and a production process that consists of the licensed work being ingested into a machine and regurgitated, at industrial scale and cadence.
**The cascading consequence**
Prns is distributed claiming dual MIT/Apache-2.0 licensing. It is, however, a direct derivative of Reticulum-licensed work, and the claimed grant is therefore void. Every downstream project that builds on Prns believing it is MIT/Apache-licensed is building on a grant that does not exist. The users of Prns, and all software developers using it, have in effect, been placed under conditions they were never told about. The "ground-up" claim is not merely false; it is the sole load-bearing element of an entire licensing posture, and it fails spectacularly.
.. _brandolinis-prns-consequences:
Consequences
^^^^^^^^^^^^
The consequences of this pattern are examined in the following sections - the harm to users and to the network in :ref:`A Movement Of A Dozen<brandolinis-movement-of-a-dozen>`, and the human dimension in :ref:`Network Health & Coexistence<brandolinis-health-and-coexistence>`. This section's contribution is narrower and intended as an instructive example: This is what a substitution project looks like, in full, on its own record. It is a reference example for :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`, and it demonstrates, in one case, most of the elements this chapter describes.
.. _brandolinis-prns-verdict:
Verdict
^^^^^^^
Applying the three verdicts of :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`, this project does not meet the standard. It is not "experimental but honest" - it is not labeled as experimental anywhere; the first thing users saw was a polished marketing presence promising a finished, tested, drop-in replacement. It is a project whose central claims are fabricated (the performance apparatus), whose provenance is laundered (the authorship machinery), whose foundation is misrepresented (the "ground-up" story), whose core semantics were learned late and by regeneration, and whose operator cannot possibly answer for any of it. It is also a blatant copyright violation of the reference implementation.
The proposed conclusion, for users and for the network: Treat the Prns project as hostile regardless of its polished surface, and as a hazard insofar as it invites users onto shared networks. Nothing in this section is a judgment about the people involved; it is a reading of the results produced, their history and how they came to be, which in the regrettable lack of any human authorship is the only thing that can be expected to be held to account.
.. _brandolinis-prns-dating:
Dating
^^^^^^
This examination reflects the publicly available material as of September 2026; the repository in question continued to receive commits at the time of writing, so readers should treat citations to commits and files as point-in-time evidence. A `forensics snapshot <https://github.com/markqvist/forensics_prns>`_ is publicly available on GitHub.
.. _brandolinis-movement-of-a-dozen:
The Movement Of A Dozen
@ -1322,4 +1065,261 @@ A lot of us rely on these networks every day. They carry our messages, our coord
They are valuable, free, and very hard to shut down. The response is not to become aggressive. It is to be *more* of what the network already is: Real, open, owned, and shared.
*Mark*
*Mark*
.. _brandolinis-prns:
Addendum A: The Prns Case
-------------------------
.. _brandolinis-purpose-and-scope:
Purpose & Scope
^^^^^^^^^^^^^^^
This section provides a concrete example, which future evaluations can use as a template. Its purpose is not to be the last word on this particular subject, but to be an example of how the ideas in this chapter can be applied, and to make the next such examination easier.
The subject of this case study is **Prns**\ , a project published at the repository ``github.com/KenAKAFrosty/Prns``\ , presented as a "ground-up implementation of Reticulum, written in Rust", marketed as faster, safer, and more strictly tested than the reference, and widely promoted with the claim of "up to 89× the throughput" of the reference implementation. The record described below is the project's own, and sourced from its GitHub repository, analyzed locally.
.. _brandolinis-project-in-brief:
The Project In Brief
^^^^^^^^^^^^^^^^^^^^
* **Time span.** 3,374 commits between 2026-05-26 and 2026-09-12: approximately 110 days,
at a mean rate of ~31 commits per day. Monthly: 132 / 1,137 / 1,097 / 805 / 203.
* **Authorship.** 3,252 of 3,374 commits (96.4%) are authored by a single account. A
second identity, "Prns Tests tests@example.test" - a fictitious identity on a reserved
domain - contributed 35 commits, every one of them website and marketing content.
* **Size.** 3,519 tracked files; 1,983 Rust files; 636,226 lines of Rust; approximately
22.7 MB of Rust source; 69.5 MB of total repository content.
* **Scope claimed.** A daemon ("drop-in replacement" for the reference daemon), embedded
firmware for three microcontroller families (including six ESP32-S3 board variants and
nRF52840), SDKs and bindings for nine languages, a browser-based node and web flasher, a
twelve-language website, a benchmark apparatus with its own publication and "proof"
pipeline, and a validation hub with oracles, fuzzing, mutation testing, and formal-proof
claims.
* **Marketing claims.** "Ground-up implementation of Reticulum"; "up to 89× the
throughput"; "48× smaller peak-memory footprint"; "33× the energy efficiency";
"Measured, not just claimed"; "Enforced, then audited"; "byte-for-byte wire parity with
the reference implementation"; "works with Sideband, NomadNet, MeshChat, etc.";
"no_std (no alloc required either)".
* **Status at the time of writing.** Version 0.3.7; published version history begins at
0.3.0. The repository continues to receive commits.
.. _brandolinis-prns-question-1:
Question 1: Is this a clean implementation, or was it directly generated from the reference?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The first of the two deciding questions from :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>` is settled by the project's own record. An actual :ref:`clean-room<brandolinis-cleanroom-delusion>` implementation, reasoned out and written by humans, would owe nothing to any license. The data available shows clearly that Prns is not that.
* **The founding state.** The first commit, "Scaffold Personal Reticulum suite", contains
the scaffolding of not one but two ports - ``personal-rns`` and ``personal-lxmf``\ , the latter
being the reference's companion messaging protocol - together with a daemon scaffold and
a 233-line founding document, ``docs/build-ethos.md``. That document declares the project's
goal as a "performance-focused drop-in-replacement for rnsd" and its governing principle
as: "Port the contract, not the implementation." It further states directly to the
machine-loop, that **"You owe the reference fidelity at exactly two boundaries:
The wire... The behavior. ... Between those two boundaries, the model is yours"**.
At this point, the very first commit, effectively the whole of the implementation design
and any relevant decisions are handed over to the LLM.
* **Continuous ingestion from the reference.** 506 commits reference RNS or Reticulum
source behaviour; the word "parity" appears in 49 commit messages. Commits cite the reference
implementation's own source locations (for example ``Transport.py:1367``) when correcting
their own divergences and mistakes.
* **Byte-level fidelity as an explicit goal.** Within 48 hours of the first commit, the
record shows a "crypto adapter - vetted primitives, byte-exact vs RNS 1.3.1", and a wire
implementation matching the reference's packet header layout. The project's own
validation apparatus decodes wire vectors using the reference implementation's own
packet parser, and the interop suite consists of real, stock-RNS peer nodes - that is,
the reference source itself, used as the ground truth against which this LLM output is
checked, and committed as accepted and verified after 48 hours of the project's recorded start.
* **The marketing mismatch.** The same record that documents all of the above describes the
project, publicly, as "a ground-up implementation of Reticulum" - while declining, on its
website, to link to the reference implementation at all: the entire tree mentions the
reference's author in six files, and the website in none.
Conclusion: the project's own history and commit record establishes that it was generated directly from the reference implementation's source code, not reasoned out from the public-domain protocol. It is a derivative of licensed work within the meaning of :ref:`the Reticulum License<brandolinis-what-the-license-is>` and :ref:`general copyright law<brandolinis-copyright-and-layers>`. The "ground-up" claim, which carries its entire legal and marketing posture, is disproven by the project's own history.
.. _brandolinis-prns-question-2:
Question 2: Who, or what, is the agent of the work?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The second deciding question is answered by the application of :ref:`Assistance Versus Machine Substitution<brandolinis-assistance-versus-substitution>` criteria to the project.
**Scope that no human could have authored**
636,226 lines of Rust in 110 days is approximately 5,800 lines per day, every day, including weekends - with 149 commits recorded between midnight and 06:00, and Saturday the single busiest weekday. No human review or decision capacity is commensurable with this volume; the review capacity and the output volume are structurally incommensurable, which is the definition of unauthored scope.
**Uniform generation**
The record shows no sign of human development, growth, or learning: No contested decisions, no style drift. Instead: endless renaming (in the first 48 hours: ``State → EngineState → TickInput → TickOutput``\ ), uniform fluent register in every commit, and the exact same, synthetic voice in code, documentation, and website copy.
**Discovery by regeneration**
Corrections arrived by the machine's own subsequent runs, recorded as planned milestones. In early July 2026, a series of "core review" commits documented, in the project's own words:
* announce-ID history "was unbounded per-slot growth" (\ ``54cc8d601``\ );
* interface announce limiting could "leak a sustained flood" (\ ``9d27af75c``\ );
* a "phantom-airtime leak" where frames "used to vanish silently" (\ ``4ed75ffdd``\ );
* Group-packet deduplication "which RNS does not do" - a behaviour the reference never had,
implemented and later removed (\ ``edd8e72be``\ );
* "both ``unwrap_or(&[])`` arms were unreachable dead defaults" (\ ``74bea355e``\ );
* a benchmark crate "hasn't compiled since" a prior rename, undetected for weeks because it
was outside the CI's workspace (\ ``86240b027``\ ).
Earlier still: the record shows a ">1 MiB RNS-to-Prns interop stall" closed three weeks in
(\ ``cc4d524a3``\ ), and a known send-path hang shipped with the note "typed fast-fail a
candidate for later" (\ ``a010e6613``\ ).
**Laundered provenance**
The repository contains a committed commit-message hook (\ ``.githooks/commit-msg``\ ) that *blocks* any commit containing attribution for machine generation ("generated with claude/codex/copilot/cursor/gemini", "co-authored-by"), with the explanation "The committer owns the commit". The contributing guide is explicit: "AI tools ... are welcome ... what you submit is *yours*", and describes the contributing population as "both human and automated contributors". The fictitious "Prns Tests" identity completes the picture: A manufactured, unknowable contributor, used for marketing content.
**Authorship by assignment**
The human whose name is on the work cannot answer for it, because the choices were never made by a human, and only the general shape and constraints of the outward presentation was. Nothing in the project's history shows an individual explaining a design decision, accepting a mistake in the first person, or going deeper under technical questioning; the record shows process language and marketing instead. Per the earlier mentioned test: any other person could have pressed the same button, and nothing would be different. The project is effectively unowned, and void of value.
By the criteria of :ref:`Assistance Versus Machine Substitution<brandolinis-assistance-versus-substitution>`, this is substitution. The machine was the agent of the work; the "author" was a facade.
.. _brandolinis-prns-performance:
The performance claims
^^^^^^^^^^^^^^^^^^^^^^
The project's central marketing claim - "up to 89× the throughput" of the reference - is also its most completely documented failure, because the project published the evidence of its own measurement. The apparatus, the results, and the problems are all on the record.
**The claim**
The README states "up to 89× the throughput"; the on-network marketing page repeats "up to 89× the throughput, 48× smaller peak-memory footprint, and 33× the energy efficiency of stock RNS 1.4.2"; the website's front page carries the tagline "Measured, not just claimed".
**The apparatus**
The reference is loaded through ``benchmarks/reference/compiled_reference.py``\ , which installs ``pyximport`` and then asserts two things: that ``RNS.compiled == True``\ , and that at least *one* RNS module was loaded from a native extension. The project's own published "proof" records show exactly what those checks captured, on every platform:
.. code-block::
aarch64-apple-darwin: .../RNS.cpython-313-darwin.so, Cython 3.2.8, Python 3.13.13
x86_64-unknown-linux-gnu: .../RNS.cpython-313-x86_64-linux-gnu.so, gcc 11.4.0
x86_64-pc-windows-msvc: ~/.prns-oc/lib.win-amd64-cpython-313/RNS.cp313-win_amd64.pyd
In every case the recorded native module is the **top-level package only** - ``RNS.so``\ , nothing below it. Nothing named ``RNS.Transport``\ , ``RNS.Destination``\ , ``RNS.Packet``\ , ``RNS.Link``\ , or ``RNS.Resource`` ever appears, because *nothing below the top level was ever compiled*. Nobody bothered to check or verify *anything* here.
The machine output was simply taken for truth, and a full marketing strategy was spun and produced on it. "RNS 1.4.2 (compiled)" - the label used in every table, chart, and marketing page - *is not a mode of RNS that exists*, but the hallucinations of a machine, which the humans created a marketing strategy on. In reality, it is the old ``CRNS`` development shim, whose top-level-only, debug-oriented "compilation" is slower than plain interpreted RNS, and which was *defunct for over a year* before these benchmarks were published.
**Interface choices**
The harness writes the reference's configuration itself (\ ``benchmarks/reference/participant_node.py``\ ): ``TCPClientInterface`` for the initiator, ``TCPServerInterface`` for the responder and both relay sides, with ``UDPInterface`` as the abstract wire. The reference was never given its modern ``BackboneInterface`` on any platform, forcing the slowest possible interrfaces. The interface selection is never mentioned in any methodology text.
**The policy**
The published default-policy tables record the asymmetry directly: Prns at 500 Mbps / 128 KiB TCP policy against the reference at 10 Mbps / 8 KiB - slyly footnoted as "preserves each implementation's normal TCP policy" (in the case of RNS, a conservative default policy that was selected to prioritize coexistence on slower, shared links, requiring the user to dial it up to full speed if they knew what they were doing). Raw transport "throughput" ratios of 20.65× (Linux) and 38.84× (Windows) are therefore mostly policy, not engine.
**The cross-host evidence**
The published results show the same scenario producing wildly different ratios by host, and the variance is entirely in the reference artifact:
.. list-table::
:header-rows: 1
* - Host
- Prns, single-packet
- "Reference", single-packet
- Ratio
* - macOS (Apple M4)
- 37.4k/s
- 420/s
- 89.09×
* - Linux (i7-1260P)
- 25.3k/s
- 3.5k/s
- 7.19×
* - Windows (Ryzen 5 5600X)
- 30.8k/s
- 3.9k/s
- 8.00×
Prns is consistent (25–37k/s). The reference artifact collapses to different depths on different hosts, and the single worst collapse - 420 packets per second on macOS - is the cell selected as the global headline. The "89×" is not a measure of Prns; it is a measure of how badly the broken baseline happened to fail on one host.
For reality calibration: Stock, interpreted RNS 1.5.4 on an ordinary mid-range laptop, single core, sustains roughly 30,000 single-packet deliveries per second (including ephemeral-key decryption), ~175,000–280,000 packets per second in transit relay, and on the order of 10 Gbps at 16 KiB payloads. The project's "compiled" artifact measured 420–3,900 packets per second for its single-packet scenario: An order of magnitude or more *below* stock interpreted RNS. The comparison being marketed was not "Rust vs Python"; **it was "an implementation running under optimal conditions versus a mislabeled, broken shim on a slow legacy interface at a severe policy disadvantage"**.
**The equalized rows**
The project's own "1 Gbps policy" rows, in which both sides are explicitly configured identically, publish ratios of roughly 2.4–8.4× across all hosts and scenarios - still against the broken baseline, but nowhere near 89×, and consistent with the ordinary, uncontroversial observation that a native implementation tends to outperform an interpreted one in raw throughput. That point needed no fudging to make, and is banal.
Interestingly, though, it seems that Prns is really only *marginally* faster than a Python implementation, running in interpreted mode, on a single CPU core.
**Assessment**
The front page says "Measured, not just claimed." The record shows the opposite ordering: claimed, and arranged to look measured. No methodology section anywhere states what "compiled" means, that it is a deprecated development shim, that it builds debug targets, or which interface the reference was given; the one statement of the policy asymmetry appears in a footnote of the results tables themselves. If they did not need to fudge it, they would have published the method clearly.
.. _brandolinis-prns-overall:
Overall Evaluation
^^^^^^^^^^^^^^^^^^
Evaluated against the conditions of :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`:
* **Provenance and attribution.** Fails: The fake "ground-up" origin story; zero reference links
on the website; a single well-hidden link in the README; a license file reading
``Copyright (c) 2026 The Prns Authors`` over work directly generated from the licensed reference;
no original copyright or permission notice anywhere.
* **Agency and answerability.** Fails on every criterion of :ref:`Assistance Versus Machine Substitution<brandolinis-assistance-versus-substitution>`:
Unauthored scope, uniform generation, discovery by regeneration, laundered provenance,
authorship by assignment.
* **Engineering.** Fails: The benchmark apparatus above; interop demonstrated only
against a pinned, outdated reference version over loopback while the marketing claims current
parity, interop failures with stock RNS; vendored prebuilt binaries and a republished fork
of an upstream crate (``nrf-softdevice 0.1.0-prns.1``) with no verifiable provenance;
committed WASM bundles.
* **Network behaviour.** Fails: Invented spectrum behaviour and compatibility claims
about third-party applications of the reference ecosystem (Sideband, NomadNet, MeshChat)
that are not established by any evidence.
* **Monetary and influence signals.** The marketing apparatus - website before protocol,
day-three twelve-language marketing, false benchmark headlines, "audited" and "formal proof"
claims - the conformal surface described in :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`:
is where this project invested.
.. _brandolinis-prns-licensing:
Licensing Analysis
^^^^^^^^^^^^^^^^^^
Applying the two legal layers established in :ref:`Copyright & The Two Legal Layers<brandolinis-copyright-and-layers>`:
**Layer A - copyright infringement (license-independent)**
The record shows a direct copy roundtrip: the licensed reference implementation fed into a machine, transformed, at a scale and cadence no human could review, with a license file asserting a fresh copyright in the operator's name and no acknowledgment of the work the project was generated from. No substantial, new human creative input is demonstrated anywhere in the record - the founding document explicitly frames the design as an instructed port of the reference's contract. A primarily machine-generated copy of a copyrighted work, not accompanied by demonstrable substantial human creative input, is a derivative work over which the copier holds no copyright, and a reproduction of which without the original author's permission infringes the original author's copyright. This holds under any license, MIT included. The operator's copyright claim over the result is, on this evidence, not merely unsubstantiated; it is the absence of one, directly asserted in the project's own writing.
**Layer B - license conditions (Reticulum License specific)**
Modern Reticulum - the current wire format, the AES-256-based link encryption, ratchets, the cryptographic machinery as it exists today - has been published under the Reticulum License since April 15, 2025, effective from release 0.9.4 and every release since. As a derivative of that work, the license's conditions attach: The copyright and permission notice must be included in all copies and substantial portions; the AI-training condition must be honoured; the harm condition must be honoured. The record shows none of the notice requirements met, and a production process that consists of the licensed work being ingested into a machine and regurgitated, at industrial scale and cadence.
**The cascading consequence**
Prns is distributed claiming dual MIT/Apache-2.0 licensing. It is, however, a direct derivative of Reticulum-licensed work, and the claimed grant is therefore void. Every downstream project that builds on Prns believing it is MIT/Apache-licensed is building on a grant that does not exist. The users of Prns, and all software developers using it, have in effect, been placed under conditions they were never told about. The "ground-up" claim is not merely false; it is the sole load-bearing element of an entire licensing posture, and it fails spectacularly.
.. _brandolinis-prns-consequences:
Consequences
^^^^^^^^^^^^
The consequences of this pattern are examined in the following sections: The harm to users and to the network in :ref:`A Movement Of A Dozen<brandolinis-movement-of-a-dozen>`, and the human dimension in :ref:`Network Health & Coexistence<brandolinis-health-and-coexistence>`. The contribution of this addendum is narrower and intended as an instructive example: This is what a substitution project looks like, in full, on its own record. It is a reference example for :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`, and it demonstrates, in one case, most of the elements this chapter describes.
.. _brandolinis-prns-verdict:
Verdict
^^^^^^^
Applying the three verdicts of :ref:`Evaluating A Reticulum Implementation<brandolinis-evaluating>`, this project does not meet the standard. It is not "experimental but honest" - it is not labeled as experimental anywhere; the first thing users saw was a polished marketing presence promising a finished, tested, drop-in replacement. It is a project whose central claims are fabricated (the performance apparatus), whose provenance is laundered (the authorship machinery), whose foundation is misrepresented (the "ground-up" story), whose core semantics were learned late and by regeneration, and whose operator cannot possibly answer for any of it. It is also a blatant copyright violation of the reference implementation.
The proposed conclusion, for users and for the network: Treat the Prns project as hostile regardless of its polished surface, and as a hazard insofar as it invites users onto shared networks. Nothing in this section is a judgment about the people involved; it is a reading of the results produced, their history and how they came to be, which in the regrettable lack of any human authorship is the only thing that can be expected to be held to account.
.. _brandolinis-prns-dating:
Dating
^^^^^^
This examination reflects the publicly available material as of September 2026; the repository in question continued to receive commits at the time of writing, so readers should treat citations to commits and files as point-in-time evidence. A `forensics snapshot <https://github.com/markqvist/forensics_prns>`_ is publicly available on GitHub.