Why We Built Lyrinox Market This Way
A Different Philosophy for Software Marketplaces
The software industry has slowly drifted away from ownership.
Products that were once purchased have become rented.
Customers increasingly pay forever for software they may only use occasionally.
Developers are often encouraged to maximize recurring revenue instead of building products that customers genuinely love.
Marketplaces reward advertising budgets.
Algorithms reward popularity.
Large publishers dominate visibility.
Independent developers struggle to compete, regardless of the quality of their work.
We think there is a better way.
Lyrinox Market was built around one simple idea:
The marketplace should reward developers who build excellent software—not developers who spend the most money promoting mediocre software.
Everything we build flows from that principle.
We Believe Customers Should Own Software
Ownership matters.
When someone buys a hammer, they don't rent the ability to hit nails.
When someone buys a book, they don't lose access because a new edition is released.
We believe downloadable software should often be treated the same way.
Not every product fits this philosophy.
Cloud infrastructure, AI services, hosted platforms, and continuously operated services often require subscriptions because they incur genuine recurring costs.
Subscriptions are appropriate when customers are paying for an ongoing service.
But many desktop applications, development tools, libraries, creative software, and self-hosted platforms do not have those same economics.
For those products, we encourage a different model.
LMVO — Lyrinox Major Version Ownership
LMVO is our recommended licensing philosophy.
It is simple.
A customer purchases a major version.
They own that major version.
Every update released within that major version is included.
When a new major version is released, it represents a new generation of the product.
Customers may upgrade.
Or they may continue using the version they already own.
There are no forced upgrades.
No artificial expiration dates.
No requirement to keep paying simply to continue using software you already purchased.
We believe customers should upgrade because your work is worth paying for—not because they have no other choice.
Ownership Should Mean Ownership
When customers purchase software under LMVO, they should feel confident using it like any other piece of property.
While each developer ultimately defines the terms of their own license, we strongly encourage licenses that allow customers to:
- Move their software to a new computer.
- Replace failed hardware.
- Reinstall after operating system upgrades.
- Continue using the purchased version indefinitely.
- Download updates released within the purchased major version.
Replacing a laptop should not require buying the software again.
Upgrading your computer should not invalidate your purchase.
Ownership should survive normal life events.
Great Software Doesn't Expire
One of the unfortunate realities of our industry is that software often disappears.
Companies close.
Developers retire.
Projects are abandoned.
Download links disappear.
Customers lose access to software they legally purchased.
We don't think that should happen.
The Lyrinox Continuity Program
The Continuity Program exists to preserve software.
Participating developers choose to archive specific releases with Lyrinox.
If that project is ever permanently abandoned according to a signed Continuity Agreement, Lyrinox may continue distributing those archived releases.
Not because we own the software.
Because the developer intentionally chose to preserve it.
Customers retain access.
Developers retain ownership.
Software history remains intact.
We believe software deserves a longer life than the companies that create it.
The Lyrinox Seal of Quality
Buying software requires trust.
Claims made by developers are valuable.
Independent verification is even more valuable.
The Lyrinox Seal of Quality exists to provide that independent verification.
Every certified product has been:
Purchased.
Installed.
Configured.
Used.
Reviewed.
Documented.
Evaluated using the same version customers receive.
Certification cannot be purchased.
Developers pay for the engineering review process—not for the outcome.
If a product doesn't meet our published certification standard, it simply isn't certified until it does.
That independence is the foundation of the entire program.
Certification Is About Improvement
Certification is not designed to reject software.
It is designed to improve it.
Developers receive detailed engineering feedback.
They receive opportunities to improve.
They receive another review.
Our objective is not to create an exclusive club.
Our objective is to raise the quality of software across the entire marketplace.
When developers improve, buyers benefit.
When buyers trust the marketplace, developers benefit.
Everyone wins.
Reputation Should Be Earned
Every marketplace has an algorithm.
The question is:
What does it reward?
Some marketplaces reward advertising.
Some reward sponsored listings.
Some reward whoever pays for premium placement.
We chose a different path.
A Marketplace Built Around Quality
Our catalog ranking system is intentionally transparent.
Products are ranked using measurable quality signals such as customer ratings, review volume, purchases, downloads, views, listing completeness, and presentation quality rather than advertising spend. Rankings are calculated on a scheduled basis and then cached to keep browsing fast and consistent.
This means that building a better product generally improves your visibility.
Buying a larger advertising budget does not.
Seller Reputation Matters Too
Products don't exist in isolation.
Developers build reputations over years.
Customers remember great experiences.
They also remember poor ones.
Lyrinox therefore evaluates not only products, but seller reputation over time through our Seller Score system. The score is designed to represent long-term trustworthiness and marketplace stewardship rather than short-term popularity, and is recalculated independently of individual product pages.
Seller reputation is earned gradually through consistent customer satisfaction, responsible marketplace participation, and maintaining high-quality products.
It cannot simply be purchased.
Fighting Enshitification
Every platform eventually faces the same temptation.
Prioritize short-term revenue.
Increase advertising.
Promote whoever pays the most.
Lock customers into subscriptions.
Make it difficult to leave.
We reject that philosophy.
We believe the healthiest marketplaces reward:
- Better software.
- Better documentation.
- Better support.
- Honest licensing.
- Long-term maintenance.
- Independent certification.
- Customer trust.
Those are the things we want our algorithms to amplify.
Not advertising budgets.
Not artificial engagement.
Not manipulation.
A Marketplace That Rewards Listening
The best developers are rarely the loudest.
They're the ones listening to bug reports.
Improving documentation.
Fixing crashes.
Answering support requests.
Shipping thoughtful updates.
Those are the developers we want customers to discover.
Our marketplace is intentionally designed to reward developers who continually improve their products and treat their customers well.
We believe that reputation should compound over time.
Just like trust.
Our Long-Term Vision
Lyrinox Market isn't trying to become the biggest software marketplace.
We're trying to become the most trusted.
We want customers to browse knowing that quality matters.
We want developers to know that engineering excellence is worth investing in.
We want software to remain available long after active development has ended.
We want ownership to mean ownership.
We want certification to mean something.
We want marketplace rankings to reward quality rather than marketing budgets.
And we want every decision we make to answer one simple question:
Does this make it easier for great developers to build sustainable businesses while helping customers buy software they can genuinely trust?
If the answer is yes, we're building the marketplace we set out to create.