Site appearance

Choose a theme and color mode

Blog / Article 004

Are We OSS Yet? Don't Take My Word for It.

Why I don't want to put a pretty percentage on Reliverse's open-source progress if I can't explain what it measures.

I could build a lovely page announcing that "Reliverse is 73% open source".

Why 73%? It looks believable. Not suspiciously round, and there's still some room left before 100. 😄

Just one small problem: I have no honest way to calculate that 73%.

I could count public files. Or lines of code. Or packages. But if I publish 500 configuration files today and one small library that another person can actually use tomorrow, which of those moves the project forward more?

That question kept coming back while I was opening Reliverse through GR Campaigns.

And it eventually became AreWeOss. Not another scoreboard of impressive numbers, but a place to see what's public, what works, and what evidence supports each claim.

On this page: A public repository doesn't answer everything · One example, several different answers · Not every checkmark proves the same thing · What the first useful AreWeOss should show · Where does Bleverse Ping fit? · Not everything in Bleverse has to be open source · So what's the percentage?

A public repository doesn't answer everything

Are we open source yet? Sounds like a yes-or-no question.

Is the repository public? Yes. Does it contain code? Yes. Done, right?

Not quite.

First, public code and open source aren't interchangeable. Being able to read a file on GitHub doesn't automatically grant permission to use, modify, or redistribute it. The applicable license matters.

Second, open-source code isn't necessarily runnable. It might depend on packages that haven't been published, require an undocumented environment, or lack a working example.

Third, a working hosted service isn't necessarily open source. And an open-source library doesn't need a hosted service at all.

Then there's source code versus a versioned package, a test file versus a passing test, a successful CI run versus something that works on another person's machine.

I don't want to compress all of that into one green dot.

I even found a good example in my own old writing. In a 2023 Relivator announcement, I promised a "20x speed increase". I wouldn't repeat that claim today without a specific benchmark and an explanation of what was being measured. It doesn't invalidate the project. It just means a catchy number isn't evidence.

One example, several different answers

Take the small read-only GR source inspection example published in reliverse/reliverse through Campaign004.

It lets you inspect a local repository's Git state without committing or pushing anything. There's a command to run it, a focused test, and a GitHub Actions workflow. I showed how to try it in Article 003.

Now imagine its page in AreWeOss.

It could say:

  • Source: there's a public path to the relevant code.
  • License: check which license actually applies to this code.
  • Reproducible example: there's a command another developer can try.
  • Checks: there's a test and workflow; the result of a specific run needs its own verification.
  • Full GR CLI release: this example alone doesn't establish one.

No need to write "readiness: 82%".

A person already knows far more than any percentage could tell them. Better still, they can follow the links and check for themselves.

Not every checkmark proves the same thing

I really like the phrase "Don't Take My Word for It".

Not because I think my word is worthless. But in engineering, it helps to separate what we claim from what we can actually verify.

Imagine an agent reporting: Campaign completed successfully.

What does that mean? The local plan is ready? A commit was created? The push succeeded? The expected files are visible in the remote repository?

Those are four different claims.

That's why remote readback matters to me in GR: checking what actually exists after publication against what we expected to publish.

I want the same honesty in AreWeOss. A public commit proves something about repository state. A test file proves a test exists. A particular passing CI run proves something about that run. A deployment has its own evidence, scope, and limits.

None of these proves all of Reliverse is ready.

There are three questions: does the evidence exist, is it current, and does it actually support this claim? A workflow file only answers the first. A particular run tells you what happened at that moment. To judge whether that's enough, you also need to know what was tested.

Evidence can go stale too. So I want each claim to have a source and a last-checked time, not just a reassuring label.

What the first useful AreWeOss should show

My first instinct was predictable: design a big system that continuously gathers signals from everything, maps dependencies, and knows the state of every package.

Then I remembered what the page is for.

Someone should be able to answer a few basic questions:

  • What's public already?
  • What can I install, run, or try?
  • Are there applicable licenses, examples, and checks?
  • What's still experimental or only planned?
  • Where did this information come from, and when was it last checked?

The first useful version doesn't need an account system, a new database, or live monitoring of my entire infrastructure.

It needs a small, deliberately public set of facts, verifiable links, and a clear way to browse them. Initially, that might be a straightforward list of components with meaningful statuses. More elaborate ways of exploring relationships can come later.

Most importantly, the public site shouldn't have direct access to my private receipts, internal permissions, or operational data from the VPS. Only information explicitly prepared for public use should leave that boundary.

A verifiable public snapshot, even without real-time monitoring, can already be useful.

Where does Bleverse Ping fit?

In the bigger picture, I imagine Bleverse Ping helping collect and verify signals about products and services.

For AreWeOss, those signals could eventually come from several places:

  • GR: Git publications and their verification results.
  • RPR: packages, artifacts, and releases.
  • RDG/RVS: specific deployment outcomes.
  • GitHub and other public sources: independent checks of what's visible to everyone.

But AreWeOss shouldn't have to wait for all of Ping. And Ping shouldn't be a prerequisite for a static page with verifiable facts.

This is turning out to be a useful test of my tendency to overengineer things. That's the subject of the final article in this series (planned for 2026-11-20).

By the way, bleverse.com is already live. The first public site was built with BVF/UIR and deployed using RPR/RDG/RVS. So this isn't a plan to someday launch Bleverse in general. It's about adding a useful, honest way to show the ecosystem's openness.

A navigation link, or even a prototype, doesn't make AreWeOss a finished product. When I describe specific features, I want to show only what readers can actually open and check. A plan, a prototype, and a public feature are different stages.

Not everything in Bleverse has to be open source

AreWeOss began with Reliverse, but it could eventually cover other parts of the Bleverse Network: Blefonix, Rengine, Bleverse Read, and more.

There's an important distinction here.

I want to open developer tools. That doesn't mean books, music, characters, game assets, and other creative works automatically get the same usage rights as the code.

An open engine doesn't make every game built with it freely reusable. A public reading app doesn't make every book in its catalog open. And a service using open-source libraries doesn't mean its code, content, and data all share the same license.

I'd like AreWeOss to make those boundaries clearer, not sweep them all under the word open.

So what's the percentage?

I don't know. And I'm not going to make one up.

A percentage might eventually make sense for a specific, predefined public scope. But only if it's clear what's included, how progress is calculated, and when the evidence was checked.

For a living ecosystem where ideas can appear faster than polished npm releases, one number doesn't explain much.

I'd rather show you one open component with an honest status, a working example, and a link to the evidence.

Because AreWeOss isn't meant to put a beautiful dashboard between "I built this" and "here, check for yourself".

It's meant to make the distance between those two statements as small as possible.

Are we OSS yet?

Not everywhere, and not everything. But every verified step should be visible. 🜂

Back to top

Author: blefnk · Language: English · Series: Introducing Bleverse

Previous article · All published articles