Tired
I’m tired of fragile systems.
Tired of crashes we’ve accepted as normal. Tired of operating systems that forget everything the moment something goes wrong. Tired of machines that don’t remember, don’t heal, don’t protect the user—only the company behind them.
So I’m building a new one.
It’s called *VaiOS*. A bare-metal, compression-first, fault-healing operating system.
It: - Compresses memory and pages at the core level - Monitors physical memory for degradation - Verifies every page with cryptographic integrity - Rolls back from memory corruption or crashes in real time - Is designed to *survive entropy, not just run code*
This is not a distro. This is not Linux. It’s written in Assembly and C, from scratch. Bootloader works. Memory map in progress. Compression-backed page recovery coming next.
Why?
Because I believe our systems should serve the user even in failure. Because I believe in coexistence with AI, not exploitation. Because I’m tired of OSes that die quietly.
Live demo and manifesto coming next week. I’d love your thoughts, questions, or brutal honesty.
If anyone’s building like this or thinking like this, I’d love to build with you.
Most crashes today are not actually caused by physical memory degradation, but rather by the bugs in software. So "memory corruption detector" is not going to help much. If a program tries to read invalid pointer and segfaults, cryptographic sums or memory compression won't help you. And with Assembly and C, there will be plenty of invalid pointers.
The "rolls back from [...] crashes in real time" does sound new and reminds me of PhantomOS. I do wonder how it deals with corruption that does not induce crashes right away - say there was a use-after-free in app that caused random memory writes... after corrupting 50 words it corrupted enough to trigger crash. Is it just going to undo that one last write, leaving the other 49 words corrupted? What about lock-ups, which do not cause crashes?
And all the talk about "machines which protect company behind them", "coexisting with AI" just smells of inexperience/naivete. How on earth compressed memory is going to help with that?
Also, "I’m tired of OSes that die quietly." makes me wonder.. could it be that all your experience is with commercial OSes, and you've never researched that part of Linux? Because Linux does not have to die quietly, there are many mechanisms (like serial console, kdump, pstore, netconsole, etc...) that give you detailed report when your system dies, with stack trace and all. I've used them in the past and they work pretty well. If you haven't played with them, given them a try! If anything, this will give you an important insight about how modern OSes work and why they crash.
You're 100% right to raise these questions! Firstly,thank you for taking the time to write them out, i expected this to just blow off into the ether so I hope I can clarify my drunk rant above.
You're right that most crashes today are due to software bugs, not DRAM decay. But the idea behind VaiOS isn’t just to detect bit rot. It’s to *rethink how failure is handled*, whether it’s a segfault, a use-after-free, or yes, even memory-level degradation on long-running devices.
I agree that cryptographic checksums won’t help with invalid pointer dereference in user space. That’s why the recovery model I’m exploring would:
- Run integrity checks on critical kernel regions and runtime-managed page zones - Use snapshot logic to roll back entire page frames, not just single writes - Map temporal fault clusters, so if a use-after-free corrupts 50 words, the rollback would address the whole block—not just the final straw that crashed it
You're absolutely right that Linux has great crash introspection tooling. Serial console, kdump, pstore, they’re battle-tested and I've been studying them.
This OS, isn't trying to compete, it’s just asking a different question:
What if the OS could not just tell you why it crashed, but actually recover from it in real time?
Imagine if a use-after-free doesn’t crash the kernel, it just triggers a “revert page region X to last valid hash” and continues execution. Maybe it logs it. Maybe it isolates the faulty process. But it survives.
PhantomOS is a fascinating reference, I appreciate you pointing me toward it.
As for compressed memory: it’s not about AI (assisted and not artificial) per se. It’s about *efficiency as resilience*.
If you can store more data with less bandwidth and thermal cost, you enable low-end devices, offline zones, and yes... agents like AI that need to work on constrained hardware in remote environments.
Inexperience? Maybe. Naivete? A little. But not ignorance. I’m not trying to prove Linux wrong, I’m trying to prove it’s possible to go further.
This isn’t about marketing. It’s about curiosity, chaos, and the refusal to accept that silence is the only way a machine can die.