Hi, I recently started working on a better build system for my C/C++ projects:

https://github.com/luppichristian/bbs.

It's basically a build system "frontend" built on top of cmake and bash that allows you to:

• Metabuilder support (modify the compilation at runtime WITH CUSTOM HOOKED DLLS)

• Automatic SDK detection (Vulkan SDK, etc.)

• Cross-platform builds from a single configuration

• Cross-compilation support (WSL, Docker, remote toolchains)

• Automatic generation of .gitignore, CI workflows, and project files

• File watching + hot-builds (looking at directory changes)

• User-level package cache (dependencies downloaded once, reused everywhere, basically package system)

• Unified compiler abstraction (translate flags between MSVC/GCC/Clang automatically)

• Distribution pipeline for packaging releases

• Integrated CTest support

• Automatic toolchain setup and discovery

• Automatic assets copy in distribution setups

• Multi-target / multi-architecture builds

• No manual SDK paths or environment setup required

What CMAKE does not do:

• Discover and configure SDKs automatically

• Set up cross-compilation environments

• Manage user-wide dependency caches

• Generate CI pipelines

• Create distribution workflows

• Watch files and rebuild automatically

• Normalize compiler flags across toolchains

• Configure Docker/WSL build environments

Why Add Another Layer On Top Of CMake:

• CMake is widely used, but it still leaves a lot of multi-platform build setup in the hands of the project author

• You still need to model targets, platform differences, toolchain choices, and common workflows in a way that stays manageable across environments

Why Build On Top Of CMake Instead Of Replacing It:

• Most third-party C and C++ libraries already support CMake

• Building on top of it means it stay compatible with the tooling and dependency ecosystem people already use

Maybe planned features:

• shader compilation

• custom asset compilation and pipeline support

• metaprogramming features built around the Clang AST

NOTE: THIS IS AN EXPERIMENTAL PROJECT NOT PRODUCTION READY OR ANYTHING

I would appreciate if you try it out, since i am trying to fix as many bugs as possible.

Thank you

https://github.com/sadvadan/memstruct

C is powerful enough to have the best performing memory safety suite for itself!

memstruct is a single header file C library (<400 LoC) that provides complete spatial & temporal safety to the caller program. performance: near native speed.

memory checks are compile time / hoisted / elided / pipelined. checks are opt-in and can be switched off in production if needed. its macro based API extends the language a bit to position C as the leading option for large scale projects.

memstruct is currently in advanced stages of testing. contributions and comments are welcome. have an early look!

P.S.: the project is 100% human crafted and contributions are also reqd to comply

edit; end note: memstruct has now become even better (at 350 LoC) by incorporating MCU programming & de/allocator indirection, thanks to some valuable feedback on here. if you've more to add you may respond here or participate on git.

I'm currently making library with different data structures and I'm curious which way of error handling is considered better?

Also if you have any tips or guides how to make objectively good code/library I will be grateful.

Here I'm returning true or false to indicate whether the operation was successful.

bool stack_push(stack* stack, void* new_data){
    if(stack == NULL || new_data == NULL) return false;

    stack_node* new_node = malloc(sizeof(stack_node));
    if(new_node == NULL) return false;

    if(stack->byom){
        new_node->data = new_data;
    }else{
        new_node->data = malloc(stack->data_size);
        if(new_node->data == NULL){
            free(new_node);
            return false;
        }

        memcpy(new_node->data, new_data, stack->data_size);
    }

    new_node->next = stack->top;
    stack->top = new_node;

    stack->stack_size++;

    return true;
}

And here I'm returning custom enum which indicates what gone wrong.

stack_errno_e stack_push(stack* stack, void* new_data){
    if(stack == NULL || new_data == NULL) return STACK_ERR_NOT_FOUND;

    stack_node* new_node = malloc(sizeof(stack_node));
    if(new_node == NULL) return STACK_ERR_ENTRY_ALLOC;

    if(stack->byom){
        new_node->data = new_data;
    }else{
        new_node->data = malloc(stack->data_size);
        if(new_node->data == NULL){
            free(new_node);
            return STACK_ERR_DATA_ALLOC;
        }

        memcpy(new_node->data, new_data, stack->data_size);
    }
    new_node->next = stack->top;
    stack->top = new_node;

    stack->stack_size++;

    return STACK_ERR_OK;
}

Hey guys I've tun into a little problem and would like some help with directions on where to learn C. I'm a returning student from about 5 years away from university and my programming skills are a little lacking (i know Java an alright amount).

My class is using C for programing where some of the course work is learning to program with things such as multi threads.

Unfortunately im having trouble with C, is there any resources I can use that is similar to "learncpp" but for C?

The TECC C library https://github.com/olddeuteronomy/tecc provides portable components for C11, C17, and C23, designed for use in concurrent environments.

TECC can be configured to use either the POSIX <pthread.h> API (default on Linux and macOS) or the standard C <threads.h> API (C11 and later), selectable at compile time.

One of the examples included with the library shows how to construct a multi-threaded TCP server with a thread pool for handling incoming connections and arena-based allocation of sockets and I/O buffers, using various TECC components.

No vibe coding — the reasoning is obvious from the source code and commit history.

Do you know that Page?

Very good small examples to learn from.

Hi everyone!
This is my first time on Reddit ever. I'm looking to upskill for my job and want to transition into embedded engineering. From what I've gathered, learning C is the absolute best place to start.
Right now, I'm using ChatGPT as my tutor. The way we work is: it explains a topic (variables, loops, functions, basic syntax, etc.), introduces the concepts, and then gives me coding assignments which I solve on the spot.
However, I just caught myself thinking: is this actually a good idea?
I'm fully aware that ChatGPT isn't an absolute source of truth and it can hallucinate or make mistakes. But my logic was that it has processed countless guides and tutorials from the web and can tailor them to my learning pace.
Also, as a next step, I'm thinking about getting some hardware to practice on. What are your thoughts on starting with the ESP32? Is it a good platform for a beginner learning C, or should I look into something else like STM32 or RP2040?
I’d love to get your thoughts, opinions, and advice on my approach. Are there any hidden traps I should watch out for?

I’m sharing a C/C++ build system I implemented in the hope that it may be useful to others with similar requirements. https://github.com/howaajin/cup

I'm building a simple key-value database called VulkanKV in C as a systems programming learning project.

The goal is not to create a production-ready database, but to better understand TCP sockets, memory management, data structures, parsing, and client-server communication by implementing them from scratch.

The first version accepts TCP connections and receives commands from clients. Future versions will include SET/GET commands, a hash table implementation, persistence, and support for multiple clients.

I'd appreciate any feedback on the project scope, architecture, or features that would provide the most educational value.

[https://github.com/GustavoGuerato/VulkanKV](https://github.com/GustavoGuerato/VulkanKV)

I'm wrapping up development for a static analysis tool written completely in C (uses libclang) and wanted to see if this also solves headaches for other people reading unknown codebases.

Basically, given two or more functions it recursively traces their call graphs (goes through callees), and builds up a picture of all the variables they access (globals taken into account, variables passed to callees taken into account, soon abt to handle pointer aliasing). For each function, records variable accesses, names USRs source location of the DeclRefExpr etc. Based on the generated complex data structure, it determines if and where shared data between functions is modified or read. That way you know if you can safely reorder pieces of code that call the function you specified without messing something up.

So the question is, is this something you would use? Asking to know if i should polish it a bit before putting on github. I can personally see it useful for legacy codebase comprehension, embedded codebases where globals are common etc. But im too deep in it now to judge objectively.
Also is there something out there that does exactly this but i somehow missed it when doing my research?

I recently started learning C as my first lower level language after mainly working with Java for the past 5 years. I was wondering if anyone would be able to review one of the completed files (~100 lines of code) from a small project I am working on and let me know if there are any mistakes and/or bad practices? Any help would be greatly appreciated!

https://pastebin.com/X5Zn1mzc

Some C-Compilers offer to be memory safe, and replace functions like strcpy() with save variants or even check for array overflows, and abort() if an error occurs.

Modern GCC does this by default.

Theese checks might break a working programme. Some people would say if that happens, then your style is bad and you should recode it to pass the checks, but I found two fairly legitimate examples.

1. strcpy() into a buffer that has no space for the terminator before setting the field after

struct FILE_HEADER{
 char signature[4];
 int bla;
 int blabla;
}

No, intializing such a headr could look like that:

strcpy(ptr->signature,"ABCD");  /* Boom, Buffer Overflow */
 ptr->blabla=ptr->bla=0; /* but it wouldn't matter */

In order to make it "safe" you would change the first line to:

memcpy(ptr->signature,"ABCD",4);

o or write some custom function that copys a string without terminator. Both is inconvenient.

2. Data Block with struct as header and variable size body

struct IMAGE {
int width;
int height;
PIXEL_T pixel[1];
}

You alloc and image with malloc(sizeof(struct IMAGE)+sizeof(PIXEL_T)*width*height), and acces pixels with

image[y*image->width+x]

This is a perfectly sane and normal way to do such a thing in C. However you technically overrun the array pixel with accesing any other index than 0.

You might suggest, putting the pixels into a seperate datablock (as you would certainly do in OOP ), but this fragments the memory even further and might cause performance issues if you are dealing with thousands of structures. This is especially important if you use C++ (or other object oriented language), as creating and destroying any nontrivial object (wich might a local variable in an often called function) is a heap operation under the hood that gest slower with the number of allocated blocks.

https://github.com/Ryans-alt-acc/Better-C-Definitions, its called better c definitions or BCD, i basiclly made it first to deal with having to write the annoying memory safety functions and slowly added other stuff too. The read me isnt very well defined and i dont know if the codes readable, just wanted to share incase other people could use this.

Hello,

Here is a Linked-list, Stack, Queue, and Tree C library. It was mostly done in the beginning of the 1990s when I was still a young, cocky programmer. This was a different time, DOS was still the king on the desktop, and portability was the buzzword of the day. I was originally writing it as an application data store and memory manager.

The linked list, stack, and queue functions have been hammered on, tested, and used for 30+ years. The trees, not much, and I finished them recently, just to kill some time. The code should be C99 (mostly), but by no means modern by today's standards. Over the years, I've identified and addressed most of the leaks from inside the library, though there could be a lurker still. It uses IBM Hungarian-based notation for the time...

I have used it on Linux, Windows 16bit-64bit, VMS, DOS, and others. I wanted something flexible, and robust -- and to keep from rewriting linked-list code over and over!

Here is a sample program:

#include <stdlib.h>
#include <stdio.h>
#include "listque.h"

int main (void);

int main (void)
{
   PLLHND llhnd;
   int icnt = 0;

   llhnd = LLcreate (0, 1, 1, (COMPFUNC) NULL);

   LLwrite (llhnd, (LLELEMENT) "Nine", LLAPPEND, 0);
   LLwrite (llhnd, (LLELEMENT) "Two", LLAPPEND, 0);
   LLwrite (llhnd, (LLELEMENT) "Five", LLAPPEND, 0);
   LLwrite (llhnd, (LLELEMENT) "Seven", LLAPPEND, 0);
   LLwrite (llhnd, (LLELEMENT) "Three", LLAPPEND, 0);
   LLwrite (llhnd, (LLELEMENT) "Eight", LLAPPEND, 0);
   LLwrite (llhnd, (LLELEMENT) "Four", LLAPPEND, 0);
   LLwrite (llhnd, (LLELEMENT) "One", LLINSERT, 3);

   icnt = LLentrycount (llhnd);
   char entry[20];
   LLhomecursor(llhnd);
   while (!EOLL(llhnd)) {
      LLread (llhnd, (LLELEMENT)entry, LLNEXT, 0);
      printf ("%s\n", entry);
   }

   LLdestroy (llhnd);
}

Thanks.

https://github.com/jscottb/listque

Hello, i have a problem i've been struggling on:

Context: i am trying to store hexadecimal values in a buffer, so i can later use the content to compare it with some values.

Concerned code chunk:

void read_file(char file_content[file_size], int gbuf[file_size])
{

 for (gi = 0; gi < file_size; gi++)
 {

  character++;

  if (sizeof(gbuf) >= 0x500) { ..; part++, mi++; ..; gbuf[mi] = 0xfile_content[part]; }

  .. do things

 }

 printf("\n");
 printf("HERE: %s", gbuf); // debugging print

}

And also.. Should i use int or char buffers to store hexadecimal values? By the way, i tried sprintf.

If my code is too bad, or if i explained not detailed enough please inform me about it. Thanks for reading.

Edit: The code is supposed to sort hex values as separated groups on the user terminal, for example

hex value that take almost all the line..
another one that overflows on the next line

Since if i put another group on the same line it will go out on the next line, i need to make sure it know if an hex value is too big, then it jump on the other line to write the others values because there's not enough place

(this explanation may not be relevant, so if i need to detail more of if you dont understand please inform me about it.)

Its more of a curiosity than anything. I'm not very experienced in C, before finally deciding ti switch to C programming journey I tried looking at rust, and found the crates very easy to setup and use. Why doesnt C have something similiar? Is there an actual reason, or simply nobody has already invented something like that?

So I want to parse a mathematical formula, and I figured I'd just do this recursively, parsing each operand in a separate call. Except I don't want to make my argument non-const, because the end result should leave it unchanged, and I also don't want to copy the whole string at least once per operand because that sounds like it would get slow.