RanvOS, (from norwegian; raven), is a operative system programmed in Rust

Related tags

Command-line RavnOS
Overview

RavnOS

Image created with Stable Diffusion 2.1

RanvOS, (from norwegian; raven), is a operative system programmed in Rust. Aims to be; minimal, stable, secure and modern ( this maybe you know as; state-of-art ).

Is my personal project to make from scratch an operative system, take this project as a hobby, nothing professional.

Target

The pillars of RavnOS are;

  • Minimalism

Nothing of bloatware inside the code or system. Just the necessary to do the job (maximum viable product).

Also the minimalism affects the system's scope, check that point.

  • Stability and security over features

Will have absolute priority the stability and security of the system over X feature.

  • Isolation and portability

Each part of system must be portable over Rust supported platforms.

Each part of system must be self hosted, no external crates (over internee) are allowed. All must be local, how can you be sure that the remote dependency is secure? how can you be sure that the remote dependency will be developed to the end of times? how can you be sure that the remote dependency will not break the compatibility?

Each part of system distributed in binary form must be done as static, at 2022 the best way for this is use MUSL standard C library.

  • Keys - Data

The information is printed in screen and worked with syntax;

[key] {
	[data]
}

This allow work with data grouped by keys and avoid issues trying to extract data when it have "", '', \, \, and others characters.

  • OS Image - Container

The final distribution must use the 'OS image' schema; the base system is immutable and the mutable part is used trough containers schema.

Requirements

  • Rustc
  • A terminal
  • Cargo with the target toolchain you want/need:

This is not mandatory but will help you to build with one just command.

  • Musl target:

This is not mandatory, but I recommend it to build as static.

Versioning

The versioning schema for releases follows Semantic Versioning v2 ( https://semver.org/spec/v2.0.0.html ), here a resume;

Given a version number MAJOR.MINOR.PATCH, increment the:

    MAJOR version when you make incompatible API changes
    MINOR version when you add functionality in a backwards compatible manner
    PATCH version when you make backwards compatible bug fixes

Additional labels for pre-release and build metadata are available
as extensions to the MAJOR.MINOR.PATCH format.

A change from early development is; each MINOR version also indicate each new / existing feature inside internal programs. And performance patches go to "PATCH" section instead "MINOR" section.

With this versioning schema you know that whiting each MAJOR version the system is always compatible with the oldest versions.

Documentation

The files with documentation like; roadmap, issues, etc are;

  • Documentation/ROADMAP.md

Contains information about ROADMAP for each release.

  • Documentation/PATRONS.md

Contains information about each patrons in each month.

  • Documentation/ISSUES.md

Contains information about each issue fixed.

  • Documentation/PARTS.md

Contains information about each system part.

Build

There are two ways for build RavnOS. ;

  • Cargo

I recommend use this configuration inside "~/.cargo/.config";

[build]
target= "x86_64-unknown-linux-musl"
jobs=20
rustflags = ["-C","opt-level=2","-C","debuginfo=0","-C", "target-feature=+crt-static","-C","target-cpu=native"]

To build;

cargo build --release --target [x86_64/arm64/etc]-unknown-[linux/windows/etc]-musl

All binaries will be in "target/[TARGET]/release".

If you have space requirements, do "strip" to the final binaries. This is because even with "--release" target I still found debug symbols in the final binary.

  • Rustc

For each RavnOS's lib you must first build them as object file and then can be used inside compilation process;

rustc --crate-type=rlib --crate-name libconfarg [PATH_TO_LIBCONFARG]/src/lib.rs -o libconfarg.rlib
rustc --crate-type=rlib --crate-name libstream [PATH_TO_LIBSTREAM]/src/lib.rs -o libstream.rlib
rustc --crate-type=rlib --crate-name libfile [PATH_TO_LIBFILE]/src/lib.rs -o libfile.rlib

Then you can link into the binary build;

rustc --target=[x86_64/arm64/etc]-unknown-[linux/windows/etc]-musl -C opt-level=2 -C target-feature=+crt-static --extern libconfarg=libconfarg.rlib --extern libfile=libfile.rlib --extern libstream=libstream.rlib [COMPONENT]/src/main.rs -o [final_name]

with above command, you will the final binary of [COMPONENT] in static final form (aka; statically linked) with optimization level 2 and specific libs (crates).

As with cargo, I recommend do "strip" to the final binaries to delete debug symbols.

Before - After strip binary

Before strip;

-rwxr-xr-x 2 shyanjmc shyanjmc 9.0M Oct 23 04:31 ls

After strip;

-rwxr-xr-x 2 shyanjmc shyanjmc 507K Oct 23 04:32 ls

The strip command clean the debug symbols, which are the 94.49869791666667% of space.

Coypright

I, Joaquin Manuel 'ShyanJMC' Crespo, am the main developer and creator of this project.

  • 2023-02-13; I have the signed copyright disclaimer agreement with my employer in which they (the company) waive the copyright on this.
  • 2023-02-13; I am in the process of registering the software at my name in República Argentina.

License

RavnOS and all parts are licensed under GPLv3.

Contact

If you want contact me, you can do it trough:

Email:

Linkedin:

Contributions and support

For now I am the main and only dev in this project, maybe in the future I will allow collaborations.

If you want support this project you can;

Join my patreon;

Donate me crypto;

  • DAI (ERC-20) - The preferred stablecoin;

0x27219354cC70dE84e7fae0B71E9e2605026b10B2

  • Bitcoin (BTC);

16n6GP4XkZiyoGCZei6uxdpohCkPm7eQ7L

  • Ethereum (ETH);

0x27219354cC70dE84e7fae0B71E9e2605026b10B2

Also you can donate trough crypto-coffee.xyz;

And if you know me personally, let me know that you have donated, since that moment we will share a beer (or mead if you are man/women of honor).

You might also like...
A lightweight and ergonomic rust crate to handle system-wide hotkeys on windows

Windows Hotkeys An opinionated, lightweight crate to handle system-wide hotkeys on windows The windows-hotkeys crate abstracts and handles all interac

An operating system written in Rust (for fun and educational purposes)

Prestige Prestige is an operating system written for fun and educational purposes in Rust. It targets the x86-64 architecture and can run on common em

A simplified general-purpose queueing system for Rust apps.
A simplified general-purpose queueing system for Rust apps.

A simplified general-purpose queueing system for Rust apps. Example // Create a new Redeez object, and define your queues let mut queues = Redeez::new

⚡🦀 Yet another rust system info fetcher.
⚡🦀 Yet another rust system info fetcher.

Yarsi: Yet another rust sys info fetcher ✨ Showcase requirements 🙀 cargo 🦀 install with $ curl https://sh.rustup.rs -sSf | sh installation ❤️‍🩹 Ya

A file watcher system written in Rust.
A file watcher system written in Rust.

fws-rs fws-rs is an application written in rust that acts as a configurable file watcher, capable of detecting real-time changes and running custom co

A version control system implemented from scratch in Rust.

Version Control An experiment to write a version control system from scratch in Rust. CLI Usage Usage: revtool COMMAND Commands: init initia

Ideas = Creations, a multi-language CMS(Content Management System) based on Rust Web stacks, with long-term upgrade and maintenance.

Ideas = Creations 中文 RustHub: Rust ideas yesterday, shining creations today! This repository holds source code used to run https://rusthub.org, it's

RustVulnsScan is a powerful system vulnerability scanner written in Rust
RustVulnsScan is a powerful system vulnerability scanner written in Rust

RustVulnsScan is a powerful system vulnerability scanner written in Rust. It allows you to perform comprehensive scans of your system to identify potential vulnerabilities and security risks.

An interprocess message bus system built in Rust.
An interprocess message bus system built in Rust.

An interprocess message bus system built in Rust, which can be used to pass messages between multiple processes, even including kernel objects (HANDLE

Releases(v0.31.0-ALPHA)
  • v0.31.0-ALPHA(Feb 14, 2023)

    0.31.0 ALPHA

    commit d5de0ec1a5d60858bc74541dcc1ef57b9c1c52fe (HEAD -> master) Author: ShyanJMC [email protected] Date: Tue Jan 24 04:52:07 2023 -0300

    Show

    • [X] File's data (normal).
    • [X] File's size (-s).
    • [X] File's lines (-l).
    • [X] File's owner (-o).
    • [X] File's permissions (-p).
    • [X] File's datetime modification (-d).
    • [X] File's words and letters (-w).
    • [X] System's processes (Linux) (--proc).
    • [X] Output mode in hexadecimal (--hexa).
    • [X] Clean mode (-c).
    • [X] Stdin mode (--stdin).
    • [X] Recognition of environment variables (-e).
    • [X] Recognition of special characters in stdin mode (like; \n , \t and others) with EOF (this depends of shell, file format, etc) as delimiter.
    • [X] Difference between two files. (--diff)
    • [X] Current date time (--date).
    • [X] Show system information (like distro, kernel version, etc) (--info)
      • For now is compatible with Linux kernel, in the future I will add BSD too.
    • [X] Adapt to work with; [key] { [data] } syntax.

    Search

    • [X] Extract data from keys

    libs / crates

    • [X] Adapt them to work with; [key] { [data] } syntax.

    0.12.0 ALPHA

    • Mon Nov 14 23:45:31 2022 -0300
    • commit 15925d1bde7222a22930b85522c29dea0e8f6f0d

    Search

    • [X] Search string inside one or more files.
    • [X] Search string in directory's name/path.
    • [X] Search string in environment variables.
    • [X] Search string in system's processes.
    • [X] Search recursively in path.
    • [X] Search in stdin.

    0.6.0 ALPHA

    • Sun Nov 13 19:53:45 2022 -0300
    • commit eb499d29c3cd67f5074841cb317d729271c3ca59

    Ls

    • [X] Directories files and sub-directories number (-l).
    • [X] Directoyies and files verbose (-v).
    • [X] Clean mode (-c).
    • [X] System's processes (Linux) (--proc).
    • [X] Fix issue with verbose mode in HOME directory. ---> Was an issue in my system with Steam folder.
    • [X] Show modified time in UTC and not in Unix Epoch
    Source code(tar.gz)
    Source code(zip)
Owner
Joaquin Manuel Crespo
An young hacker and lover of Linux systems.
Joaquin Manuel Crespo
First project in rust which will be to make an accounts system & Leaderboard/Score system

rust-backend this is my first project in rust which will be to make a backend for compsci project it will include: Accounts, Player Achievements (if I

NaughtyDog6000 2 Jul 13, 2023
Pure-Rust rewrite of the Linux fontconfig library (no system dependencies) - using ttf-parser and allsorts

rust-fontconfig Pure-Rust rewrite of the Linux fontconfig library (no system dependencies) - using allsorts as a font parser in order to parse .woff,

Felix Schütt 28 Oct 29, 2022
Another TUI based system monitor, this time in Rust!

Another TUI based system monitor, this time in Rust!

Caleb Bassi 2.1k Jan 3, 2023
Simple system monitoring app that runs on terminal. Made purely with Rust.

What is it? RCTOP is a simple WIP system monitoring app that runs purely on terminal and doesn't feature GUI. One can compare it to htop, but more str

Niko Huuskonen 7 Oct 14, 2022
🌳 A lightning-fast system fetch tool made with Rust.

?? treefetch A lightning-fast minimalist system fetch tool made in Rust. Even faster than neofetch and pfetch. Made to practice my new Rust skills ??

Angelo-F 134 Dec 14, 2022
skyfetch ☁️ a system information fetch written in rust

skyfetch ☁️ a system information fetch written in rust requirements cargo install with curl

leo. 31 Dec 15, 2022
An experimental real-time operating system (RTOS) written in Rust

An experimental real-time operating system (RTOS) written in Rust

null 0 Nov 14, 2022
Bracket QOS - a Quality of Service/Experience server system writtin in Rust. Derived from the excellent LibreQOS Project.

Bracket QOS - Open Source Edition This project is based on the excellent LibreQOS project. It is hoped that this can be useful for the upstream projec

Herbert 12 Dec 2, 2022
An online judge system written in Rust.

MROJ - Making a Rust Oneline Judge Background This repo was initially a homework of Tsinghua University Programing and Training Course, but I found it

hjsjhn 6 Nov 29, 2022
A system fetch tool for Linux, written in Rust.

fetchit A system fetch tool for Linux, written in Rust. fetchit is a simple system info tool, written in Rust, for Linux based operating systems. It o

Ruturaj Nanoti 26 Nov 21, 2022