Join the discussion

Write your take first — we'll ask for email only when you're ready to publish.

  • Hacker News
  • Modern operating system, ready to face challenges of today political landscape, should natively support "hidden" encrypted containers, that is you would log in to completely different, separate environment depending on password. So that when under threat could disclose a password to an environment you are willing to share and attacker would have no way of proving there is any other environment present.
  • It would be easy to tell for anyone seriously after you: If I kidnap you and make you log into your computer, and you log into the decoy state, it'd be obvious to see that the last time you visited any website etc. was over a month ago and so on.
  • The only thing political about this project so far is that I insist on it being free software and also free from tivoization. Well that and not going to insane lengths to support hardware whose vendors are clearly hostile to third party operating systems and free software in general like Apple and Qualcomm.
  • Interesting, and kudos for trailing other paths, and not being yet another POSIX clone.
  • Thanks and that was one of my main motivators for starting this. There just arent any options out there that aren't POSIX or Windows. I guess there's Haiku but even that's based on an older OS.
  • How does this compare to SerenityOS? At a glance, it looks more modern and free from POSIX legacy?
  • I don't know anything about SerenityOS so I can't really say but if you have any more specific questions I'd be happy to answer them.
  • Written in Rust. Hmm.

    SerenityOS is written in C++.

    I'd love some kind of meta-language that is easy to read and write, easy to maintain - but fast. C, C++, Rust etc... are not that easy to read, write and maintain.

  • fast necessitates manual control -> more semantics for low level control) that need to be expressible, ie: more complex

    easy to understand, maintain -> computer does more work for you to "figure things out" in a way that simply can't be optimal under al conditions.

    TLDR: what you're asking for isn't really possible without some form of AGI

  • Being maintainable comes down to code quality, comments, and documentation. These are thing that I really want to emphasize for this project but for now I'm just one guy and it's very early days so I have to focus developing core kernel components first.
  • I’m very happy I’m seeing more open source kernels being released.

    More options (and thus) competition is very healthy.

  • > GPLv3 or later (with proprietary driver clarification)

    What's that parenthetical mean?

  • There's a note in the repo that clarifies the meaning of the GPLv3 regarding the use of combining covered works with proprietary libraries when the resulting combined work is never conveyed. It doesn't modify the license, it just explains what it means in that specific case as we interpret it.

    Also to be clear I am not a lawyer and nothing I say constitutes any form of legal advice.

  • Looks like it's explained here: https://github.com/charlotte-os/Catten/blob/main/License/cla...

    Specifically, "Users may link this kernel with closed-source binary drivers, including static libraries, for personal, internal, or evaluation use without being required to disclose the source code of the proprietary driver.".

  • It's comforting to see that capabilities with mandatory access control have become the new normal.
  • Why choose one when combining both is better?
  • So, what's modern about it? "novel systems like Plan 9" is quite funny because Plan 9 is 30 years old.
  • That's still newer than Linux's system design.
  • Plan 9 is novel compared to Unix which almost every OS in common use mimics. But the reference to Plan 9 was more as a nod to its namespace and suitability for distributed computing which partially inspired my design.
  • Some people seem to like throwing around "modern" as a buzzword. I tend to automatically filter that out.
  • The sad part is that there are too many ideas of old systems lost in a world that 30 years later seems too focused on putting Linux distributions everywhere.
  • I love seeing projects in this space! Non-big-corp OSSes have been limited to Linux etc; would love to explore the space more and have non-Linux, non-MS/Apple options. For example, Linux has these at the core which I don't find to be a good match for my uses:

      - Multi-user and server-oriented permissions system.
      - Incompatible ABIs
      - File-based everything; leads to scattered state that gets messy over time.
      - Package managers and compiling-from-source instead of distributing runnable applications directly.
      - Dependence on CLI, and steep learning curve.
    
    If you're OK with those, cool! I think we should have more options.
  • Have you seen TempleOS?
  • Fuchsia
  • BSD exists Also Open Solaris Minix etc...
  • > Package managers and compiling-from-source instead of distributing runnable applications directly.

    Docker tries to partially address this, right?

    > Dependence on CLI, and steep learning curve.

    I think this is partially eased by LLMs.

  • Linux is a big corp OS. Look at who the biggest contributors are and who funds the Linux foundation, ultimately paying Linus and friends' salaries.
  • Haiku, plan9, redox, and Hurd comes to mind

    Reactos if you need something to replace windows

    Implementing support for docker on these operating systems could give them the life you are looking for

  • This is probably a better introduction it seems, than specifically the kernel of the OS: https://github.com/charlotte-os/.github/blob/main/profile/RE...

    > URIs as namespace paths allowing access to system resources both locally and on the network without mounting or unmounting anything

    This is such an attractive idea, and I'm gonna give it a try just because I want something with this idea to succeed. Seems the project has many other great ideas too, like the modular kernel where implementations can be switched out. Gonna be interesting to see where it goes! Good luck author/team :)

    Edit: This part scares me a bit though: "Graphics Stack: compositing in-kernel", but I'm not sure if it scares me because I don't understand those parts deeply enough. Isn't this potentially a huge hole security wise? Maybe the capability-based security model prevents it from being a big issue, again I'm not sure because I don't think I understand it deeply or as a whole enough.

  • I believe redox is doing the same (the everything as an URI part)