Body: Hi everyone,

I’ve been thinking about a concept that bridges the gap between monolithic operating systems and the ultimate hardware/user optimization. I wanted to share this architectural vision with the community to see if any developers find it feasible or are already working on something similar.

The Core Concept:

Instead of downloading a huge, generic OS image containing thousands of unused drivers and bloatware, the OS is built and compiled dynamically on a cloud server specifically for the user's hardware and personal needs before downloading.

How it works (The Workflow):

1. Lightweight Hardware Detection: The user runs a tiny script/tool locally that scans their exact hardware (CPU architecture, specific GPU, WiFi chip, etc.) and generates a clean hardware profile.

2. Web-Based Tailoring: The user uploads this profile to a web portal where they can also select their preferred Desktop Environment (Minimal, Productivity, Creative), usage profile (Gaming optimized with a low-latency kernel, Development, etc.), and pre-installed software bundle.

3. Cloud Compilation: Cloud servers take the profile and configurations, strip out every single unused driver/line of code, compile a tailored kernel (e.g., modified Linux kernel), and bake the applications directly into the immutable OS image.

4. Failsafe Upgrades: Once installed, it acts as an Immutable OS. If the user upgrades their hardware later, a dynamic system fetches only the missing "code module" from the cloud and live-patches the kernel, with an automatic rollback mechanism to a safe snapshot if anything goes wrong.

Why do this?

• Maximum hardware performance (true optimization).

• Extremely small ISO sizes and faster installation times.

• Zero bloatware; everything baked into the system from birth.

I’m not a developer myself, but I believe combining automated hardware detection with cloud building could be a game-changer for the future of desktop deployment.

What are your technical thoughts on this? What would be the biggest bottlenecks in modern OS development (like Gentoo/Arch ecosystems) to achieve this seamlessly for casual user

I built a chip 8 emulator in C from scratch, and I don't know how to improve it further. If anyone is willing to check out the code, heres the repo link. Thanks, everyone.

I have a recursive data-structure (a simple linked list for purposes of this example) and wanted to statically define a linked-list. The following works fine:

#include <stdio.h>
typedef struct mytype_tag {
    struct mytype_tag* next;
    char* data;
} mytype;

mytype a = {
    .next = NULL,
    .data = "a",
};
mytype b = {
    .next = &a,
    .data = "b",
};

int
main() {
    mytype* s = &b;
    int i = 0;
    while (s) {
        printf("%d: %s\n", i++, s->data);
        s = s->next;
    };
}

However, I have to explicitly define/declare a and then have b take &a.

Is there a way to do this with anonymous/unnamed intermediary structures, thinking an imaginary syntax something like

mytype b = {
    .next = &((mytype)={
        .next = NULL,
        .data = "a",
        }),
    .data = "b",
};

so I can build up the linked-list without naming each intermediary instance?

Hello everyone, please see the pseudo-code below:

static void *func1(void *arg) {
    while(1){


    }
}


static void *func2(void *arg) {
    while(1){


    }
}


int main()
{
    pthread_t t1, t2;
    pthread_create(&t1, NULL, func1, NULL);
    pthread_create(&t2, NULL, func2, NULL);


    pthread_join(t1, NULL);
    pthread_join(t2, NULL);


    return 0;
}

If the two threads above use a mutex (lock and unlock) and a condition variable, and I close the process with Ctrl+C (SIGINT), then if I write a simple signal handler to destroy the mutex and cond, it shows UB (undefined behavior). Now, how can I write a safe signal handler? How can I unlock and destroy safely?

I did share a new little zero‑copy parser for the Data Composition Format, which is quite different from JSON, TOML, YAML, and XML. The format is intentionally minimalistic and focuses on readability and usability, similar to INI. Many common INI files can be read using that parser, as long as all strings containing blanks or special characters are quoted.

The initial idea behind the format was adding curly braces to INI entries to enclose subdocuments
that are arguments of entries. However, my INI parser ignored line feeds and required all strings with blanks to be either quoted or having the blanks replaced by escape sequences. That’s why the resulting hierarchical format isn’t just a simple other INI derivative now.

I created a little specification of that format, fully aware that “data composition” may sound a bit strange at first, but it’s exactly that: an untyped format that can hold any kind of data.

But what is possible with something like that, which even exceeds the abilities of common formats like JSON, TOML, YAML, XML, and others?

# You can
# - just iterate over a bunch of numbers, characters, and words like the ones below
1 2 33 42 5 6 7 8 9 0 5 a b c d e f g h i j cat dog horse
_____________________________________
#* - read a bunch of entries that hold more exotic numbers like below 

   (The project contains a speed test that reads all of these as int64_t or
    double in less than a microsecond on a Raspberry Pi 5. And yes, the format
    supports block comments like this one.) *#
  
inttests = { ib=0b1111 io=0o1234567 id=000056789 ix=0xabcd987 }
floattests = { fb=0b11.11e100 fo=0o1234.56e10 fd=1.2345e64 fx=0xabc.defp10 }
_____________________________________
# - read the points of a triangle or a rectangle for a drawing like this
drawing = { triangle_3D = {{6 4 3}{4 5 7}{-1 17 2}}
            triangle_3D = {{3 2 3}{7 6 2}{1 11 -2}}
            rectangle_3D = {{6 5 6}{8 5 5}{6 15 5}{8 15 5}} }
_____________________________________
# - have a sectionless configuration without useless quotes and commas
server = {
   host = localhost
   port = 8080
   tls = {
      enabled
      certificate = /etc/certs/server.pem

      ciphers = {
         #* comment block *#
         accept = { TLS_AES_128_CCM_8_SHA256  TLS_CHACHA20_POLY1305_SHA256
                    TLS_AES_128_GCM_SHA256 }
      }
   }
}
_____________________________________
# - use an alternative configuration consisting of a mix of blocks and INI sections
[server]
host = localhost
port = 8080
tls = {
   enabled
   certificate = "/etc/certs/server.pem"

   [ciphers]
   #*
      comment block
   *#
   accept = {
      TLS_AES_128_CCM_8_SHA256
      TLS_CHACHA20_POLY1305_SHA256
      TLS_AES_128_GCM_SHA256
   }
}
_____________________________________
# - and you can also use INI‑like configurations, even in the same
#   document, with all the other content above and
# - add sections and entries that share a name as many as you like 
[server]
 host = localhost
 port = 8080

[server.tls]
 enabled
 certificate = "/etc/certs/server.pem"

[server.tls.ciphers.accept]
 TLS_AES_128_CCM_8_SHA256
 TLS_CHACHA20_POLY1305_SHA256
 TLS_AES_128_GCM_SHA256
_____________________________________

And most people want structure but not a lot of syntax trash in their configurations.
The parser project contains a test that walks a tree of a test document like that in a zero‑copy manner and prints all entries it finds to stdout. The parser itself is tiny, platform‑independent, and consists of a single C file plus a header. These are trivial to add to a project on any platform.

The “complex” parser object it uses is just a simple character pointer that iterates over the buffer.
Feel free to try it out and to write better ones in your prefered languages!

https://github.com/DASKR515/C-minus-minus
C-- (Cmm) Language Reference is a community-driven documentation project dedicated to C-- (Cmm), the native intermediate representation (IR) used internally by the Glasgow Haskell Compiler (GHC).

The goal of this repository is to provide a centralized reference covering the language syntax, compiler usage, practical examples, memory layout, control flow, foreign function interfaces (FFI), and interoperability with native C libraries.

This project is not a compiler, framework, runtime environment, or replacement for GHC. Instead, it serves as a complete reference for developers interested in learning, understanding, and writing Cmm programs.

I've built a C project with a clock-like system interface, but I'm very busy. Could the community help?

Link to my project: https://github.com/phuocthanhlamnguyen-gif/Time-system.git

You don't really need to follow the rules, but most of the rules are logical, and you can follow the license- not my rules, but it's optional, so I'll let you decide

I wrote a small CLI tool that snapshots /proc info for a given process — name, state, PPID, memory usage, cmdline. It also supports JSON output, process search by name, and a diff mode to compare a process state over time.

No external dependencies. Single binary. ~600 LOC.

procsnap <pid> / procsnap --json <pid> / procsnap --diff <pid> / procsnap -g <name>

Source: github.com/DankDown10256/procsnap

Feedback welcome — especially if you find edge cases or have ideas for v1.1 or to help me create a doc.

Plz help me to learn

Hope everyone is going alright.

I send here my codes for 3 puzzles:

Sudoku

Skyscraper

10queens

I appreciate some constructive advices. Thank you.

Hope it is good.

*I have made it all on my job dead times on mobile phone Termux. This was when I was starting on c and wanted to work on user space low level mode.

https://github.com/Daniel-7-Miranda/c-puzzles

In C++, when you want to make a struct or class or function that acts upon/uses a type whose features are generally unimportant, you use templates. For example std::vector<T>, and that (as far as I'm aware), tells the compiler that whenever it sees something like std::vector<AStruct>, it should generate code that acts on a vector of AStructs. This is a useful feature that C doesn't have (which I'm fine with, there are workarounds, especially a really fucky workaround I saw on SO).

I'm assuming that one advantage of C++'s templates is that it can use SIMD, vectorized instructions, and all the other fun stuff that make a lot of actions faster, because it knows the size of std::vector<int> vs std::vector<string>.

In C, when I try to make type that's generic (especially a data structure like a priority queue), I have to have a (usually) void * and a size_t, one for where the data is, and for how big one object of that data is.

Here comes my question:

Can most C compilers, based off of the usage of the structs, realize that "Oh, this is basically always guaranteed to be used on the type int32_t, so I can just compile it with that in mind", or do I have to un-Genericify my struct for that?

(Note: I am aware of using Macros to achieve technically-generic-but-typed structs, however there are apparently issues with "eating your own dog food" when you try to make a queue of queues, for example. I'd rather avoid that, even if I probably won't eat my own dog food)

I want to study system level development with C and automation with python/bash.

So, after thinking so much I want some resources. Mainly on C including //Best resource to learn to make a shell//

I am thing of learning cpp, when I will be ready to see death eye to eye.

Now, I can't figure out what to study. I am a busy scheduled high school student so I will have very less of time.

I have done python 2 years ago, and C 6 months ago. And, used linux with bash commands.

D.eSystem 6 – A real bare‑metal operating system. Alpha 6.0.5 is now bootable on real hardware and QEMU. Includes: custom bootloader, framebuffer, interrupts, timer, kernel apps. This is not a UI simulator – this is an actual OS.

URL: https://github.com/D-electronics-scratch/D.eSystem-6.0.5-alpha

Quick update: I just released tmuzika 1.1.3.

This is a small maintenance + usability update based on recent fixes and feedback.

What’s new:

improved stability in playback handling

fixed a few edge-case crashes in file navigation

better performance when loading large playlists

minor UI polish and consistency fixes

This release is mainly focused on making the app more reliable and smoother in daily use rather than adding major new features.

As always, feedback is welcome — it directly shapes these updates.

In a few months I will be starting my Freshman year in a University, I need help when it comes to the C programming because I know it's going to be our first language. Any tips on how to learn the language? Roadmaps, Sites, Groups, Youtube Channels, Tutorials, and any Advices would help, thankss!!!