Ring++ has two sibling projects, built by the same person and sharing nothing but a language: RingScript, which runs Ring inside a web browser, and RingServ, a web server in a single binary. A third, MicroRing, is still coming.
None of them depends on Ring++, and Ring++ depends on none of them. That makes them an unusually good test: real code, written without Ring++ in mind, by someone who cannot claim the tool was tuned to flatter it.
So the checker was pointed at both of them, read-only, nothing modified. Here is everything it produced.
The results
| what was examined | what came out |
|---|---|
| Dormant bugs in either project | Zero. Both clean |
| Places Ring++ would genuinely help | One, in RingServ — a specific spot handling data the slow way |
| Places Ring++ would help but is not needed | One, in RingScript — which had already built the same trick by hand |
| Mistakes found in Ring++'s own published claims | Two. Both corrected |
Zero is a result, not an absence
It is tempting to treat "found nothing" as a wasted afternoon. It is the opposite. The checker's whole value rests on being right when it says code is fine — so two real codebases coming back clean, with no invented problems to wade through, is precisely the outcome that makes the tool worth running on a third.
A checker that finds something everywhere is not thorough. It is noisy, and eventually nobody reads it.
The interesting one: a wheel reinvented identically
RingScript needed to read a large list quickly. Ring++ has a facility for exactly that. It turned out RingScript had already built the same thing by hand — arriving independently at the same approach, for the same measured reason.
Which means Ring++ had nothing to offer there. Two people looking at the same language reached the same answer, and the honest conclusion is that the second implementation is redundant rather than that the first should adopt it.
The useful one was about us
The genuinely valuable finding was not in either sibling. It was that running against real outside code caught two mistakes in Ring++'s own published claims — statements on this site and in the documentation that did not survive contact with someone else's codebase.
Both were corrected. That is the recurring theme of this project: the measurements that matter most are the ones that contradict something already written down.
It is also the argument for pointing your tools at code you did not write. Your own repository agrees with you. It was built by the same hands, under the same assumptions, and it will keep confirming them.
The complete account, including where Ring++ honestly does not apply, is in SIBLINGS.md — written before the results were known, so it could not be arranged to flatter anyone.