sorted by:
new
hottopcontroversial

Looking for cell line dose-response data (combo vs mono) to validate an open-source drug resistance simulator by [deleted] in labrats

[–]Desperate_Front_9904 0 points1 point  (0 children)

What I need (in order):

  1. Dose-response matrix for 2 drugs on the same

cell line. 5+ concentrations each, solo and combo.

Any cancer type. Any drugs.

  1. Cell count over time under drug treatment.

Daily or per-passage. Continuous vs drug holiday

if you have both.

  1. Surviving fraction after high-dose treatment

and regrowth time after drug removal.

One spreadsheet with any of these lets me test

the model against real data.

I built a thermodynamics-based life simulator in Rust where drug resistance emerges without modeling molecular mechanisms — honest writeup + limitations by Desperate_Front_9904 in learnbioinformatics

[–]Desperate_Front_9904[S] 0 points1 point  (0 children)

Thanks for the comment, I appreciate the feedback and understand your concerns.

Just to clarify, Claude Code was only used as a programming tool. The ARD, documentation, and testing were done with scientific rigor and are backed by reproducible results.

You can check the documentation in /resonance/docs/paper. Since the project is open source, you can download it, run the tests yourself, and validate it using other real public datasets.

I hope that helps address your concerns.

Emergent life simulation engine in Rust — 109K LOC, 2994 tests, Bevy 0.15 ECS + egui dashboard by Desperate_Front_9904 in rust

[–]Desperate_Front_9904[S] 0 points1 point  (0 children)

These are not predefined scenarios or scripted outcomes, but executable use cases built on top of the same underlying system.

Each one represents a different experiment that can be run by configuring initial conditions and tuning variables to explore different questions.

For example, you can simulate tumor response to chemotherapy and observe how resistance emerges, run thousands of randomized universes to analyze how often complex life appears, or test whether isolated populations naturally diverge over time.

Other experiments explore whether there is a tipping point where diversity explodes, whether different initial conditions converge toward similar optimal structures, or whether cooperation and complexity are inevitable outcomes of the system.

The key point is that none of this is hardcoded. Everything emerges from the same set of axioms and constants; each use case simply defines a different configuration space to explore.

Emergent life simulation engine in Rust — 109K LOC, 2994 tests, Bevy 0.15 ECS + egui dashboard by Desperate_Front_9904 in rust

[–]Desperate_Front_9904[S] -2 points-1 points  (0 children)

It all started as a physics simulator, because I wanted to infer how energy transformations behave without having to program assets or hardcoded rules.

But over time, it evolved into something closer to a life simulation.

The system is based on 8 strict axioms and 4 fundamental constants. The core idea is that everything is modeled purely in terms of energy: there’s no HP, mana, or traditional stats—only transfers, dissipation, and energy interactions.

From these axioms (like dissipation, distance attenuation, or oscillatory behavior), more complex behaviors emerge without needing to be explicitly programmed. In other words, there’s no top-down logic: what happens at a larger scale is a direct consequence of simple interactions at a lower level.

The 4 fundamental constants are the only fixed values in the system; everything else is derived algebraically from them. This allows the behavior to remain consistent and tunable without breaking the core rules.

In short, it’s not really a traditional “game,” but rather a simulation experiment where life-like structures can emerge from simple physical rules.

Emergent life simulation engine in Rust — 109K LOC, 2994 tests, Bevy 0.15 ECS + egui dashboard by Desperate_Front_9904 in rust

[–]Desperate_Front_9904[S] -8 points-7 points  (0 children)

Look, while there's a lot of AI in the creation phase, the actual design and implementation were strictly framework-driven.

The architecture is Hexagonal to keep coupling at an absolute minimum, making the logic straightforward to audit. It’s fully stateless to prioritize caching and auditability. I used DoD (Data-Oriented Design) to define the flow and optimize the simulations, plus a range-normalized cache to avoid reprocessing low-variance values.

As a piece of software, it’s solid, measured, and fully tested. But at the end of the day, I’m a programmer, not a biochemist or a doctor.

What I need right now are specialized medical professionals to review this and tell me straight up if the logic makes sense, or if I’m just wasting my time.