Evolvix — A Stable Extensible Humane Computer-Language for Biology#
Evolvix is being envisioned as a long-term stable extensible humane computer language, designed to simplify accurate biological modeling under the deep uncertainties of life. This page introduces Evolvix to newcomers and bridges from the 2015 Prototype that already works to envisioned futures that offer a stark choice. This choice is being made by the global decision to either continue to do nothing — or to support the narrow path to adopt a new funding model to make a life-giving future real.
Why a stable extensible humane computer language?#
Most computer languages optimize for short-term productivity. They add features quickly, accept breaking changes between versions, and treat last year’s code as legacy debt. For day-to-day software this is often workable. For science that needs to last across decades — so that today’s models can still be read, re-run, and trusted by tomorrow’s researchers — it is the chaos of oblivion.
Evolvix aims to meet all 3 hallmarks of this life-giving trifecta:
stable — backwards-compatible over the long term, so models written today still run a generation from now without rewrites.
extensible — able to grow new features without breaking old ones, so the language can keep up with new science.
humane — intuitive for biologists who are not professional programmers, so the people who actually understand the biology can write the models.
The hard part is all three at once, indefinitely. Most language designs get one or two and lose the third under pressure. The Evolvix research program treats this trifecta as the central design problem and ties it to explicit processes for keeping the trifecta in place while still allowing for innovation at the cutting edge. This requires a participatory naming methodology and the use of advanced naming technologies, such as developed in the Evolvix BEST Names model for synonyms that serve different naming priorities. It also requires a radically different funding model in order to protect Evolvix from getting captured by short-term special interests. To understand why, it’s best to start with a simple model for describing what destroys computer languages over the long term.
How Blind Assumptions destroy computer languages#
Computer languages tend to collapse the same way civilizations do, and the mechanism is so familiar that anyone who has worked with a language over decades can recite it.
A “simple” feature is added because someone needs it. To make it work with everything else, more rules are added around it. To make those rules work, exceptions are added. The exceptions need their own exceptions. Within a few years the language has accumulated a thousand small papercuts that nobody wants and nobody can remove without breaking something downstream.
The compounding does not stay in the syntax. Needlessly complex syntax inspires needlessly complex code: programs grow workarounds for the language’s quirks, those workarounds become idioms, the idioms get copied into more programs, and soon the programs are also too tangled to reason about. The bug surface explodes. Mathematical reliability slips silently. Eventually the only people who can maintain the system are the experts who built the tangle, and outsiders cannot check what is happening — which is exactly when accountability dies and catastrophic failure becomes only a matter of time.
This three-step erosion — over-simplifying a problem at the start, then over-complicating the workarounds that hide the simplification, then over-reaching into places the language was never meant to go — is what Balospe.com names the OSCR pattern (Over-Simplifying, over-Complicating, over-Reaching). OSCR is the operational mechanism: hover the term to see the full glossary entry or follow the link.
OSCR is in turn one symptom of a deeper algorithm that runs by default in any system without active resistance: Blindly Assuming Blind Leveraging, abbreviated BABL. BABL is the strategy of acting on untested assumptions and pushing those actions for short-term wins; OSCR is the operational pattern that emerges when BABL runs unchecked. Computer languages and civilizations alike accumulate avoidable complexity when they blindly assume and blindly leverage anything available to grab the next low-hanging fruit. The accumulated avoidable complexity is what eventually crushes outsiders’ ability to check the math, and shortly after that, even insiders’ ability to fix what is breaking.
Resisting this requires more than good taste. It requires rejecting almost every “good idea”. As the Prototype Evolvix Compiler — Zenodo Archive of Past Foundations puts it (see the Mathematical Reliability section): for every one best idea included in a long-term stable language, 99 or more “good ideas” must be rejected in the search for the abstraction that best serves the common good. Not just over the next release cycle, but over the long term — a phrase used so often on Balospe.com that it gets the abbreviation OLT. Languages that go for low-hanging fruit accumulate avoidable complexity by default; languages that serve the common good OLT require active, sustained, funded restraint — which brings us to the alternative algorithm that has to be chosen on purpose.
(For the general framework behind BABL and the algorithm that opposes it, see the dedicated central page: War of the Algorithms: BABL Math Destruction vs ZION Math Deduction.)
How Active Self-Correction saves computer languages#
The opposite of blindly assuming and blindly leveraging is deliberately testing and self-correcting — the same cycle a careful farmer runs without thinking about it.
The farmer’s cycle has four steps, in this order:
seed: prepare the ground and sow the seed (zone the field, decide what is planted where, get it into the soil). This is the start of the cycle.
feed: tend the growing crop. Water it, feed it nutrients, guard it against obvious and overwhelming problems, investigate what is going right and what is going wrong, adjust as needed.
grow: as the crop matures, give it the time it needs. Allow it to organize the developing yield. Support it by staking the tomatoes, thinning the seedlings, training what is climbing, managing what is filling out — so that the maturing system stays coherent rather than collapsing under its own weight.
reap: bring in the harvest, store what was gained, prepare for the next round (which includes deliberate rest before the next seed-step). Reap is also where the farmer navigates from this cycle to the next: what worked, what did not, what to plant differently next time.
No step can be skipped. An unseeded field grows weeds. An unfed crop dies. An unorganized maturing crop can tangle itself, fall over, and rot before harvest. An ungathered harvest rots in the field. An unrested farmer ruins next year’s soil along with themselves.
The same four-step cycle — seed feed grow reap — is what Balospe.com names the ZION algorithm: Zoning (seed), Investigating (feed), Organizing (grow), Navigating (reap). ZION is the self-correcting alternative to BABL. Where BABL leverages assumptions blindly, ZION tests them deliberately at each step. Where BABL produces the OSCR drift toward avoidable complexity, ZION produces a system that stays long-term reasonable (sustainable across generations), equally kind for all sides (not capturing benefits for some at the expense of others), and dynamically gentle in its transitions (no sudden collapses dressed up as “necessary”). This is here called the life-trifecta: a fused quality with three irreducible aspects — gentle kind reasonable — that can only mean what they mean when all three hold together.
For a computer language, the seed feed grow reap cycle looks like this:
Zoning (seed): think hard about which aspect of reality the language is going to model and refuse to accept any feature that does not fit that scope. The seed determines what can grow at all.
Investigating (feed): every proposed feature gets tested against worked real-world examples and adjusted as the testing reveals problems. This is where the language is fed and watched while it is still pliable.
Organizing (grow): as the language matures, organize the growing set of features with consistent naming, clear documentation, and visible trade-off lists, so the maturing system stays coherent rather than tangling under its own weight.
Navigating (reap): release stable versions that users can actually rely on, and navigate from one cycle to the next — including deliberate rest from feature pressure, retrospective on what the language is becoming, and decisions about what not to add in order to keep the system reasonable for the next century.
The cost is real: 99 rejections for every 1 inclusion, sustained over years. But the result is a language that newcomers can still read in 2050 and experts will still find useful because the same principles that made it work in 2015 still apply, unchanged. That is the long-term return on the ZION algorithm.
(For the same algorithm applied to civilizations, social systems, and personal life, see War of the Algorithms: BABL Math Destruction vs ZION Math Deduction and the crisis page that quantifies what happens to systems that run BABL at scale.)
Why Evolvix research is itself a BABL-to-ZION journey#
LLoL’s Evolvix research from 2013 onward can be told as a personal encounter with this algorithm-war. The 2015 Prototype Evolvix Compiler was already an attempt to do better than the BABL-default of biological modeling tools at the time — but completing it made one thing clear: short-term funding cycles, special-interest capture, and the “keep-shipping-features” pressure of conventional academic software were a perfect breeding ground for the very BABL pattern Evolvix was trying to escape. Continuing on that path would have produced exactly the kind of avoidable-complexity tangle the language was meant to avoid.
So between 2015 and 2026 the work shifted. Rather than racing to add features to the Prototype, LLoL went on a wide interdisciplinary diversity-encouraging research marathon (defining the wid-e methodology) to find deeper solutions. He eventually asked a different question: what would it take to fund and govern language design in a way that stops running BABL and reliably follows the ZION algorithm? The answer required reaching far outside the conventional language-design literature — into governance theory, theology, mathematics of self-correction, and ultimately the funding-model and systems theory framework that is being developed at https://balospe.com.
The bridge from the 2015 Prototype to the envisioned future is therefore not a software project. It is an attempt to change which algorithm runs the way computer languages for biology get funded and maintained. That is what the funding-model section below is about, and that is what the new funding model is designed to enable. However, as became increasingly clear since 2020, funding Evolvix is merely one example of a whole host of common goods problems that lack the support they need for humanity to avoid self-destruction. Thus, LLoL had to ask himself if he wanted to invest in the long-term stability of a language that will not be needed in a century if the world self-destructs at some point in the next decades. Hence, LLoL was forced to confront the same hard question all the funders had to face when asked to support a general-purpose language like Evolvix: Where would LLoL draw the boundary? Which existential disaster for life would he be willing to ignore in order to “get Evolvix done”? See diverse parts of the Balospe.com website for LLoL’s struggles and resulting decisions, which eventually led to the funding model described for Evolvix below.
Why biouncertainty matters — and why it needs language-level support#
Biology is uncertain by default. Almost all measurements carry error. Almost all parameters are distributions, not simple numbers. Almost all “unknown” quantities can usually be pinned to a min and max only 4–6 orders of magnitude apart even when biologists claim ignorance. And almost all “known” quantities come with a spread of values from real-world variation.
Modeling languages designed for engineering tend to treat uncertainty as an afterthought — something the user adds on top of a deterministic core. Evolvix flips this. The vision is for biouncertainty to be a first-class citizen of the language itself: every parameter, every data value, every model output carries its uncertainty alongside its value, and the language tracks the propagation automatically.
This matters far beyond academic biology. The Coronavirus pandemic of 2020 showed in stark terms how badly real-world decisions go when uncertainty estimates are missing, miscommunicated, or deliberately suppressed. The same pattern shows up in climate models, biodiversity assessments, drug-safety reviews, general pandemic forecasting and beyond. A language that handles biouncertainty natively is a language that makes it harder to accidentally mislead with a model — and easier to be honest about what we genuinely do not know.
From 2015 Prototype to envisioned future Evolvix#
Evolvix research has produced one working artifact and one work-in-progress research program. Both matter; neither alone is enough.
The Prototype (2015) — what already works. The Prototype Evolvix Compiler (version MMv0r3p1_c1, archived 2015m03d11) is a domain-specific language for simulating biological systems where parts randomly meet to trigger actions at defined rates. It is not the envisioned long-term language — it is a working prototype of the core mass-action modeling concepts (Parts, Actions, Rates), with both stochastic and deterministic simulators that produce mathematically reliable results. It was used extensively by Loewe in the EvoSysBio Group at UW-Madison from 2013 through 2018 for research, teaching, and outreach.
For the full description, downloads (Mac, Windows, Linux), and a 2026 installation guide for modern systems, see:
Prototype Evolvix Compiler — Zenodo Archive of Past Foundations — the Zenodo archive description, with download links, citation, and the historical context that motivated the envisioned future.
The envisioned future — what does not yet exist. The 27 documents in the STa1-EVX stadion (overview) sketch what a long-term stable extensible humane Evolvix could look like: flipped language design that starts from biological concepts, DOISI (a Data Oriented Insight Storage Infrastructure echoing diverse aspects of the Spirit of Boolean truth), the andOr Witches for improving clarity in expressions of Boolean logic, the problem of ambiguous semantics of nothing, a framework for diverse realms of biodata science, and a participatory naming methodology that makes long-term semantic reproducibility possible through innovative synonym scaling technologies.
The gap between the working prototype and the envisioned future is real and large. Closing it is not a matter of more code — it is a matter of sustained common-goods funding for the kind of language design that no single special-interest funder can support alone; it is also a matter of finding new ways for experts and non-experts to work together in order to recognize each other’s respective strengths that are essential for such a computer-language to succeed.
A new funding model for common-good languages#
The Prototype Evolvix Compiler — Zenodo Archive of Past Foundations page documents (in Funding and institutional context) the limitations of special-interest based funding mechanisms. The pattern is this: enthusiastic agreement that a language like Evolvix would benefit everyone is followed by reluctance to fund it because anyone else could also fund it. Biologists may point to computer scientists and vice versa, academia may point to industry and vice versa, and so on, usually in larger networks for shifting responsibilities, such that everyone can maintain plausibly that they all did what they could. And so work that is meant to serve everyone dies death by a thousand needles — in a classical tragedy of the commons.
Loewe decided to not let this slide, even after exhausting all conceivably existing avenues he ever heard of or could imagine.
And so Loewe set out in 2020 to search for a different funding framework — one that resists special-interest capture and is designed to support general-interest language work for the common good over the long term. This search was interrupted by the Coronavirus, which can be seen as a call to Loewe to use the 2015 Prototype Evolvix Compiler to serve the purpose it was developed for: building models that matter for existential questions. This led to his discovery that many of the foundational common goods funding challenges of Evolvix can equally be applied to pandemic research. This led to the unexpected (LLoL!) discovery of the framework that is being developed at https://balospe.com as part of the broader ResearchCity vision for public talent research stadia with transparent arenas. The need for such a research stadion to coordinate pandemic response research became very obvious, as obvious as the need for the Evolvix vision to be supported by such a stadion of researchers as well.
This bridge from the 2015 Prototype to the envisioned future is exactly the kind of work the new funding model is designed to enable. Whether that bridge gets crossed depends in part on whether enough people recognize that long-term stable extensible humane computer languages are a common good worth supporting with up to ca. $8/year/person in order to defend such work against special-interest capture by creating a fiduciary responsibility to transparently work towards the common good for all. Then enough people need to act on that realization in order to buy-in as explained below.
How you can help - as a non-expert#
If the trifecta of stable extensible humane sounds like something you would value in the computer languages of this world that everyone is forced to rely on indirectly, then please support:
Audit the math. The
#AuditTheMathcampaign at Buy In to add your ca. 2 cents/day support for globally challenging the experts required to independently re-check the mathematical infrastructures LLoL has been developing to scale up ResearchCity.As ResearchCity scales up and Balospe.com learns to offer more accessible ways to provide feedback on specific questions, please consider contributing to its FeedbackFlow. Until then, whenever you make gentle kind reasonable choices to aid life-giving decisions, then you you are already contributing.
How you can help - as a Computer Expert#
If the trifecta of stable extensible humane sounds like something you would value in computer languages of the future, you will likely have your own ways of working towards that goal. Here some ideas:
Read the Zenodo description to understand what the working prototype actually does, and the stadion overview to see the broader research documents that sketch the envisioned future.
Cite the prototype if you use it, so the work has a visible trail (citation block at the bottom of the Prototype Evolvix Compiler — Zenodo Archive of Past Foundations page).
Engage with the funding-model work at https://balospe.com if you see ways the framework could support the kind of long-term language research described above.
Send feedback via the FF link at the bottom of this page if you see ways to make this introduction more gentle kind reasonable for the audiences it tries to reach.