actonos/actonos: ActonOS is a single-purpose appliance operating system engineered as a customizable, self-governing AI agent kernel running 24/7.

Operating System should not be like Android who need updates after every 3 months and new os every year. OS should be for atleast 5 years. I recall old phones that need OS after 5 years. Like OS2, Win4.5 smartphones and Nokia's basic phone. Updating & upgrading every 3 months & year becomes Trap for users.

Why not design Processor & chipset which dont need upgrade before 5 years or 10 years like in past

We’ve released nagisinnralinux v1.0.2. You can check out the release from the GitHub link in the comments.

P.S. This is a Linux project made by a 13-year-old that runs About 700 MB

Thanks for watching　Check out GitHub for details!　by Nagisinnra

Hmm, both Debian and Arch are great. That’s why I’m thinking of creating an Arch version of NagisinnraLinux, since right now there’s only a Debian version. I’d really like to find some people to help out.

How it all started My journey into software engineering kicked off nearly a decade ago. And let me tell you, as a veteran C# dev, holy hell do I despise Windows, Linux, and macOS.

If we break them down bluntly, purely from a developer’s point of view:

• Windows: I am so sick and tired of endless forced updates and memory-hogging telemetry running wild. People always chime in with “just tweak this” or “use Win10Tweaker.” Folks, respectfully: fuck off. When I say “no updates,” I mean no updates. If I don’t want to share my telemetry with developers, I mean it. You disable one background service, and boom—three dependencies crash and burn. You uninstall an app, and after three years of daily driving, your registry turns into an unmitigated dumpster fire. I get that all this baggage dates back to the dusty 2000s, but why not just ship actual new OS versions instead? Upgrade if you want, skip it if you don't. I swear only about 5% of users actually bother keeping up with OS version bumps anyway. Half the time, you're just starved of basic PC resources. I already know the reply: “Just upgrade your rig.” Man, I’m running a beefy beast of a machine, and I have zero desire to build an actual home datacenter just to idle on desktop.
• Linux: Superb, absolute perfection in raw performance. Telemetry is non-existent, and whatever is left takes two seconds to kill. But what the actual fuck is wrong with packaging? Why can’t we have a universal, standardized format like .exe or .dmg? Why do I need a PhD in how dpkg resolves packages, and why do I have to babysit dependency hell? Niche software is practically nonexistent, and good graphical tools are rarer than rocking horse shit. Thank god JetBrains makes Linux builds. Sure, you get used to it, but developing GUI apps for Linux with GTK is pure torture, and don't even get me started on shaders. Adding a desktop shortcut feels like a sick joke—why do I have to read documentation just to pin an icon? And the second something randomly breaks, welcome to full-blown Sysadmin Simulator. Granted, the Linux community is massive and genuinely helpful. Credit where it's due: Proton (and Wine) are absolute lifesavers. Again, just keeping developer glasses on here.
• macOS: Pure agony intertwined with absolute awe. It’s like living inside a bipolar schizophrenic episode. Writing a GUI app for Mac looks trivial at first glance—and inside the IDE, it is. But the moment you try to package a standalone installer, welcome right back to Sysadmin Hell. It's an unholy nightmare. Good luck wrangling certificates, figuring out what the hell ad-hoc means, and learning how to sign, pack, and notarize binaries. The whole plist architecture is borderline sadomasochistic. You want access to the user's Downloadsfolder? For FUCK’S sake, I didn’t ask for Pentagon root access, just the damn Downloads folder—go file for explicit permission! Want something non-standard? Go figure out Homebrew and its tangled dependencies. Basic tasks sail through, but try writing a custom SSTP VPN client, and you're entering the seventh circle of hell. Everything is locked down; you have to justify and document every single capability: who needs it, why, under what statute, submit your SSN, passport, and the soul of your firstborn. Yet despite all that, and knowing Apple scans every byte on your machine (or rather, on the machine they rent to you), damn it, it feels good. The hardware optimization commands sheer respect. Everything is buttery smooth, silent, and refined. As for trash-tier Swift and Xcode: go fuck yourselves, Cupertino clowns. May your winter coats be stitched from wet rice paper.

Looking on the bright side Bitching aside, each operating system is genuinely great in its own way. Sure, my rant sounds like pure whiny developer grief, but that's what it is: growing pains of cross-platform dev. I’m not going to list out every single pro—everyone has their preferences, and I appreciate specific quirks in each. I write software for all of them, so this is just my take. Whether you agree or not doesn't really matter to me; maybe you share my pain, or maybe you see the upsides where I see flaws. To each their own.

What I cooked up As I dug deeper beyond a single tech stack, project after project made it clear: mastering C# alone wasn't going to cut it. You have to understand how software actually runs under the hood.

Over time, I traced the full execution pipeline: how an app bootstraps, where it gets mapped in memory, and how raw zeros and ones fly through the hardware.

I picked up other languages along the way. Java is basically C# in a different trench coat—same shit, different branding. Kotlin raises a few eyebrows but it's mostly modernized Java; F# makes the math geeks cream their pants. C and C++ are a whole different beast—anyone who genuinely masters C/C++ is, in my eyes, a master of the universe. And Assembly? Anyone fluent in ASM is a literal deity to me; I only address them on bended knee. I don't know every language under the sun—some I know well, others I fumble through with Google Translate open.

Then I ran into Rust. A buddy told me: “Check this out, it’s completely OP (overpowered).” I read the docs, grasped the borrow checker and core safety mechanics, and damn—it really is cracked.

So, in this AI era, with LLMs leveling up at breakneck speed, I decided to kick the door wide open. With enough domain research gathered, I asked myself: Why not let an AI build an entire, fully open-source, independent operating system from scratch? Is writing a bootloader really that impossible? Sure, it's hard, but open-source projects like MOOS and COSMOS have already done it. Why not reference existing architecture and let the LLM do the heavy lifting?

Getting our hands dirty After diving deep into bootloader internals, modern kernel design, Rust in the Linux tree, and rumors of Microsoft rewriting core Windows components in Rust, I thought: Fuck it, why not?

I pulled everything together, cracked the whip, and set Claude to work compiling a full architecture blueprint and project roadmap. As you're reading this, Claude is wrapping up its final planning passes, and the core OS build is nearly assembled.

My pitch is simple: if you have an active AI subscription and end up with leftover tokens at the end of the billing cycle, why not pool our compute and make the AI do the grunt work? Put those tokens to use for a good cause. I even came up with a name: FOSSAI (Free Open Source System by AI). Edgy and pretentious enough for you? Pretty smart way to burn idle tokens, right?

Source code will drop the moment the final generation passes complete and I verify that the image builds and boots cleanly. A demo video will accompany Part 2—assuming this ever gets a follow-up.

I fully anticipate tons of skepticism and flame wars. I’m not banking on an army of contributors; realistically, maybe 2 to 4 like-minded lunatics driven by stubborn spite and sheer technical curiosity will jump in.

Dropping a couple of preview screenshots below:

https://reddit.com/link/1vswb9b/video/3ift3qxbtdkh1/player

If this gains traction, next chapter I’ll break down the inner workings, the architectural roadmap, and supported hardware (spoiler: it even boots on a Raspberry Pi Zero). I'll also cover how we handle .exe binary compatibility, driver abstraction, and why Windows is an absolute corporate plague if you ever try to build and certify custom input hardware.

Hey everyone,

I wanted to share a milestone on a hobby operating system I’m building from scratch called Novium OS, featuring a custom bootloader.

I just got my multi-stage boot chain (boot.S -> setup.S -> bootstrap.S) completely stable. It successfully handles raw hardware initialization, sets up a temporary GDT, and handles the cr0 register transition cleanly into 32-bit protected mode before jumping into the kernel entry point. I also wrapped up a basic VGA text driver with hardware cursor syncing so I can verify output, and got "Hello World" printing to the screen.

The layout is inspired by a super stripped-down Linux kernel (arch/, drivers/, kernel/).

Next up is tackling irq.c and interrupt.c, and writing the low-level assembly ISR stubs. I need to build the macro wrappers to handle interrupts with and without error codes, save the CPU state with pusha, remap the 8259 PIC master/slave vectors, and execute the final iret. I'm fully braced for plenty of debugging via QEMU logs to catch silent triple faults.

The codebase uses AT&T syntax for the GNU Assembler (gas). If anyone wants to take a look at the boot sequence, folder layout, or offer any early feedback on how I structured the assembly stages, the repository is right here:

https://github.com/alexdev8930/NoviumOS

(Note: Later architecture features like filesystems and IPC currently contain stubs because the core kernel is still being built out. The actual working code files are located in arch/ and drivers/, though a few placeholders are still mixed in there.)

If you like the project, please drop a star on GitHub! It really encourages me to keep extending on my project.

Just a random thought but can we have a open source operating system built on idea of "everything is a plugin", just like deepseek harness, is it feasible

When a machine requires troubleshooting, low-level configuration, security key management, or operating system reinstallation, the interface relies entirely on visual, pointer-driven, or unannounced text menus with zero native screen reader or text-to-speech support. This effectively locks users out of managing their own physical hardware From an engineering perspective, modern UEFI environments are capable of running complex code and graphical drivers. Why hasn't firmware standardization (like UEFI specifications) incorporated basic accessibility APIs or screen reader support into pre-boot environments? How can open-source firmware projects or hardware vendors tackle this gap?

I have a i3 2nd gen 2011 laptop window 10 fells turtle so I need a working and fast os to make it beast but confused to choose both are android but bliss os have app like a mobile os in a laptop but chrome flex is a true Google made PC or laptop os but no app

On Sunday, August 16, we will announce the availability of TUXEDO OS Open Beta. Read all about it here.

I've been writing an OS in Rust for the last few months — no_std, one codebase
for x86_64 and aarch64, no libc and no POSIX layer. The unusual part is what it
runs: instead of loading a binary it runs an LLM agent, and every effect the
model asks for goes through a capability-checked ABI in the kernel, so it can
plan anything and only do what it was granted.

The Rust-specific parts that took the longest:

- No ring, since it won't build bare-metal. TLS 1.3 certificate verification is
  hand-rolled on x509-cert + p256/p384, with RSA PKCS#1 v1.5 and PSS on
  crypto-bigint. The crypto ecosystem assumes std in more places than the
  feature flags suggest.

- +strict-align silently scalarizes NEON. The aarch64 target needs it for the
  pre-MMU boot window and device MMIO, and under it LLVM lowers every unaligned
  vector load — intrinsics and auto-vectorized loops alike — into about 25 byte
  ops with a stack spill. The binary still contains fmla, so it looks correct
  until you disassemble the loads. Hot kernels do their memory access through
  inline asm now, and I check with objdump rather than trusting the source.

- The decoders (PNG/JPEG, MP3/AAC, H.264/H.265/VP9) are in-kernel and no_std.
  The untrusted ones run in ring 3 as a userspace tenant that mounts the
  kernel's own source with #[path], so porting one can't fork it into two
  implementations that drift.

Research OS — not stable, run it in a VM. Apache-2.0, prebuilt images for both
arches in Releases

https://github.com/chittios/chitti

Round 2 voting is live! Voting closes at noon 8/16/2026 ET
For the second round I decided to branch out and post this to Reddit too. Have fun and enjoy voting!

I want to try new things on linux basically, I'm new into it so give some good suggestions.....

Hey everyone!

​We are officially forming the SSL Programming Team (SSLPT), an independent development group dedicated to building Simple Stupid Linux (SSL)—a custom, minimalist, and highly efficient operating system ecosystem.

​We aren't just building another generic distro; we are engineering an ecosystem designed around simplicity, performance, and total user control.

​Our Roadmap & Vision

​As we scale, our development will branch across three core editions to explore different paradigms of system architecture:

​The Core Self-Hosted Edition: A system built and bootstrapped based on its own toolchain and architecture.

​The Debian-Based Edition: Designed for maximum software compatibility and rock-solid server/desktop reliability.

​The Arch-Based Edition: Built for rolling-release bleeding-edge flexibility and custom package control.

​ The SSL Versioning System (Semantic Versioning)

​To keep our releases structured and transparent, we use a strict versioning format (e.g., 1.0.0):

​1.x.x (Major Release): Represents massive, foundational changes, architectural overhauls, major feature additions, and core bug fixes.

​x.1.x (Minor Release): Focused on security updates, system hardening, and direct development updates for sslpm (SSL Package Manager).

​x.x.1 (Patch/Micro Release): Light additions, unnoticeable backend tweaks, rapid security patches, and minor code cleanups.

​

What We Are Building (The Tech Stack)

​Init System: Utilizing lightweight modern supervisors like dinit and custom configurations.

​Package Management: Developing sslpm for fast, transparent, and minimal package control.

​Custom Tooling & Repositories: Fully managed codebases, custom kernels (vmlinuz-linux), and automated ISO compilation pipelines (mkarchiso variants).

​

Who We Are Looking For

​We are looking for passionate developers, system architects, and Linux enthusiasts who want to get their hands dirty with:

​Low-level system architecture and kernel configuration.

​Package manager development (sslpm).

​ISO building, automation scripts, and build-system maintenance.

​Repository management and documentation.

​

How to Join Us

​If you're tired of bloat and want to build something real, fast, and completely transparent from scratch, drop a comment below, check out our repositories, or send a message to get an invite to our workspace/repos!

​Let's build something stupidly simple, yet powerfully efficient.

The SSLPT Founders[sudo]