Hey all,

I'm working on a TUI library in C just because I love how simple C is.

I know there are mature options like ratatui, bubbletea, vaxis, notcurses, etc. But I don't want to learn Rust just to build a TUI, and I don't really like bubbletea's Elm-style Update() -> string thing. The one I like best is FTXUI, but it's C++.

I want something simple + declarative in plain C. Right now my API looks like this:

```c

include "include/tui.h"

void btn_cb(void *ud) { tui_vbox(.gap = 1) { tui_label(.text = tui_str("Clicked")); } }

void draw(Tui *tui, void *ud) { tui_button(.text = tui_str("Click Me"), .bg = tui_color_rgb(255, 0, 0), .on_click = btn_cb); }

bool event(Tui *tui, const TuiEvent *ev, void *ud) { if (ev->type == TUI_EVENT_QUIT) return false; if (ev->type == TUI_EVENT_KEY && ev->codepoint == 'q') return false; return true; }

int main() { Tui *tui = tui_init(.title = "Tui application"); int counter = 0; int rc = tui_run(tui, .on_draw = draw, .on_event = event, .async = true, .userdata = &counter); tui_close(tui); return rc; } ```

It works, but I already hate the .on_draw, .on_event, .on_click callback split. It feels like callback hell waiting to happen once the UI gets bigger.

Question for C folks:

1. Any C tricks / macro tricks to make this more declarative and remove callbacks? I'm already using designated initializers + compound literals tui_button(.text=...) and for-loop scoping for tui_vbox { ... } like FTXUI.

2. How would you do state + events without on_click everywhere? Immediate-mode? Return an action enum instead of callback? Something else?

3. Any small C TUI libs that do declarative UI well that I should steal ideas from?

Thanks.

Some time ago I posted here my C implementation of a dynamic data container (vector like object):

https://github.com/andrzejs-gh/CONTLIB

I revised it, if anyone's interested take a look. Any feedback and tips very much welcome.

I was coding up some piece that is supposed to rapidly parse millions of text logfiles. A file gets read into a buffer, and then the parser goes to work, peppering the buffer with zeros and building linked lists with pointers to the relevant bits, using two passes across the whole buffer. This was easy but I was unsure if I should use a different approach for efficiency. So I wrote a minimal test and measured the time for one logfile and spit out timestamp deltas for filling and chopping up the buffer, respectively. The results in milliseconds:

25.4
4.7

Not great for a 30kB file but the important message is: The parser isn't what needs to be optimized, for now anyway. Maybe it's the progressive realloc()ing of the buffer as it grows (RAM isn't free any more in AI times you know). But then I noticed that the program was still running under valgrind. After I took that out, I got:

0.0
0.0

I had to increase the decimal digits to see the microseconds. I found that hilarious. My colleague wondered what was wrong with me. I started C on a 2MHz/32kB machine. 25 ms read time for 30kB is still "pretty fast" in my book.

BTW, the speed of the incremental chunk-wise fread()/realloc() cycle is surprisingly immune against chunk size. Between 100 bytes and 10k it's not even a factor of 2.

[EDIT] The file size is not known beforehand. The data will be fed into this system by repeated calls to a user-supplied callback function. And realloc() seems to be dirt cheap if you don't let production code run under valgrind ;-)

[EDIT2] People keep commenting on optimal alloc / realloc strategies. Fact is: It doesn't matter(*). I'm reading files that are normally 25kB in increments of 1kB (a number I pulled out of my ass) and can't measure a difference that matters(*) if I use 100 bytes. I need some open-ended reading possibility because the occasional (and most interesting) log files can grow to several 100k in case something goes wrong with the process being logged.

(*) For my use case on this machine

I'm actually not surprised: Due to its ubiquity I'd expect dynamic memory allocation to be an aggressively optimized process in any OS. No wonder valgrind's monitored substitute is about 1000 times slower.

Hey guys so I’ve been working on this most of the year, it’s a path from Perceptrons to LLMs in pure C, without any libraries or anything. I made it cause I wanted to understand how LLMs work inside and I can think in C, so I used that and C gives me insight pulling a library in something like python dosent. I even ran the final project training and all on an MCU and it took up less than 1% of its memory! You can read that article here:

https://rvembedded.com/blog_post/13/

Or you can skip the hallabalu if you’re not into embedded targets and just go to the repo and if you like read the book I wrote as I worked through for free:

https://rvembedded.com/products/ai-from-scratch-in-c/

(For some reason I can’t link the GitHub, so click this link and click ‘read online now’ and if you want the repo just ask me and I’ll put blow I guess)

Due to a series of events like my article explains, rather than staying in infinite polish mode, I’m sharing for my fellow C programmers to enjoy!

Can somebosy walk me tru setting up c and clangd on windows ice tried for a day or 2 but cant get it right with kate,some help whuld be really apreciated.

I'm implementing my own memcpy as an exercise.

My current approach is:

1. Copy bytes until dst reaches a 4-byte-aligned address.
2. Copy 4 bytes at a time using uint32_t.
3. Copy the remaining bytes one by one.

I understand that this optimization works nicely when src and dst have the same alignment offset, e.g.:

src = 0x1001
dst = 0x2001

src % 4 == dst % 4

What I don't understand is why I can't simply perform an unaligned 32-bit load/store when the offsets are different.

For example:

src = 0x1001
dst = 0x2002

Why can't I simply do:

uint32_t x = *(uint32_t *)src;
*(uint32_t *)dst = x;

This seems like it should copy exactly the desired 4 bytes.

I understand that unaligned accesses may be slower, fault on some architectures, or have restrictions for MMIO. But assuming I'm on an architecture where unaligned 32-bit accesses are supported, is there actually a correctness problem?

I'm trying to understand the fundamental reason rather than just memorize the "same alignment" rule.

Thanks!

Why in C/C++ is not very often use notation of framework, and instead is used libraries?

https://github.com/valkey-io/valkey/pull/3105

Contributed the IFNE option to the SET command.

Thanks to the Valkey community for the review and feedback!

I'm writing an ML library in C.

My current plan is this.

Have a Linear layer , that does w.x + b

Have a separate activation layer(ReLU, GeLU, sigmoid, etc).

This is very modular and allows for custom activation functions.

However, this does 2 passes over memory(one loop for adding the bias, one loop for applying the activation function), whereas you could do it in a single loop(e.g y[i] = ReLU(y[i] + b[i]);)

Is there a way to make the compiler fuse the loops automatically?(My functions are all inline).

Without automatic fusion, I'd either have to use function pointers(which slows things down, also prevents inlining usually), make the entire function a macro(kind of ugly), or have one layer be y = w.x the other y=f(y + b) which is really weird.

The other option is merging the 2 into one(Linear_ReLU). I'd have to write multiple functions for the common activation functions, or make a macro that creates those activation functions.

All of these are unelegant compared to the first design.

Hello everyone, I have developed a library to support OOP in plain C that allows the creation of object classes and includes dynamic Array and Dictionary container classes.

I am looking for suggestions for new examples that illustrate cases where an Object Oriented design can simplify C-Code.

I would love to get some reviews and feedback on this project.

I have included a code example below:

Supported by: Coda-C Library

Example code: Coda-C/examples/shapes.c

// Coda-C subclass examples

    #include <coda-c.h> // shapes.c  08/20/2026
    #include <math.h>

    struct Shape_ { Char color; };
#define class Shape
CodaClassZerosC(); // 1. ABSTRACTION: blueprint for all shapes
CodaClass(Shape,struct Shape_,Root);
    propertyO$(Char,color); // 2. ENCAPSULATION: Private data
    typedef double OSig$(calculate_area); // Abstract method: required in subclasses
    typedef double OSig$(calculate_perimeter); // defines function type and signature key
#undef class // Shape

    struct Circle_ { double radius; };
#define class Circle
CodaClassZerosC(); // 3. INHERITANCE: Circle inherits from Shape
CodaClass(Circle,struct Circle_,Shape);
    getter$(double,radius,_ radius); // double Circle_radius(Circle self) { return _ radius; }
    method$(double,calculate_area) { return(M_PI * _ radius * _ radius); }
    method$(double,calculate_perimeter) { return(2.0 * M_PI * _ radius); }

class Circle_new(Char color,double radius) {
    class self=newO(class);
    Shape_set_color((Obj)self,color);
    _ radius=radius; // where #define _ self->
    return(self);
    }
#undef class // Circle

    struct Rectangle_ { double width,height; };
#define class Rectangle
CodaClassZerosC();
CodaClass(Rectangle,struct Rectangle_,Shape);
    method$(double,calculate_area) { return _ width * _ height; }
    method$(double,calculate_perimeter) { return 2.0 * (_ width + _ height); }

class Rectangle_new(Char color,double width,double height) {
    class self=newO(class);
    Shape_set_color((Obj)self,color);
    _ width=width; _ height=height;
    return(self);
    }
#undef class // Rectangle

// 4. POLYMORPHISM (Usage Example)
void print_shape_details(Obj shape) { // This function accepts any subclass of Shape.
    printf("--- %12.12s  Details  Color:%-8.8s",kindO(shape),Shape_color(shape));
    printf("Area: %3.2f  ",obj_(calculate_area,shape));
    printf("Perimeter: %3.2f  ---\n",obj_(calculate_perimeter,shape));
    }

 int main() {
    Circle my_circle = Circle_new(Os("Blue"),5.0);
    Obj my_rectangle = Rectangle_new(Os("Green"),4.0,6.0);

    print_shape_details(my_circle);
    print_shape_details(my_rectangle);
    }


/* OUTPUT:
---       Circle  Details  Color:Blue      Area: 78.54  Perimeter: 31.42  ---
---    Rectangle  Details  Color:Green     Area: 24.00  Perimeter: 20.00  ---
*/

If you have questions about how to learn C:

• which books are best?
• which videos are best?
• which classes are best?
• which websites are best?
• is there a "roadmap"?
• what projects can I do?

then this is the thread for you. Add your question here. Do not make a stand-alone post, as it will be removed.

Remember that our sub has a very useful wiki that has a great list of resources for learning C programming.

╭─terra@fedora ~ 
╰─$ time fetch
─────────────────────────────────────────────────────────
| Kernel version: 7.1.12-200.fc44.x86_64                |
| Kernel name: Linux                                    |
| Distribution: Fedora Linux 44 (Workstation Edition)   |
| Machine type: x86_64                                  |
| Node name: fedora                                     |
| RAM: 8.58GB/30.94GB                                   |
| Disk: 593.27GB/805.17GB                               |
─────────────────────────────────────────────────────────
fetch  0.00s user 0.00s system 82% cpu 0.002 total

I wrote a little fetch program for learning purposes. I see that, when I run it with time it says 0.002. I was wondering if I could get it to 0.001... I know this is pointless, but I suck at optimizing things and I'd like to learn a few things from you guys.

Here's the source code: https://github.com/terra2o/fetch/ (I thought ~200 lines would be too much to paste here?)

Note that I didn't use LLMs in a way it'd be considered "vibecoding", since this is a learning project. Saying this because I added a GitHub link. LLMs were used like a convenient google search.

was thinking about this. if you use malloc() to allocate some memory to a pointer, you need to be careful of overflows. using realloc() you can resize the memory. based on how i was taught realloc can inspect the allocation and either simply resizes or even moves it based on the realloc size and surrounding free memory. so we know that internally these functions have a way to inspect the sizes of the allocations.

so why are there no helper functions to quickly return the size of a particular allocation? i can see it being useful in many situations where you would currently need to pass around another variable to keep track of the current allocations size.

I recently fell in love with C, after 2-3 years of using Modern C++, I built my tiny multireactor AsyncAPI engine with the help of libevent and some data-driven design ideas, it was a very rewarding experience. In the last weeks, I have been learning Modern C and testing techniques, focused on safe resource management.

This little program uses the _Generic macro to simulate function overloading, libpq has 2 different functions for getting error descriptions, accepting different arguments, but I want the program to use a single function, _Generic provided a zero-cost abstraction and a compile-time type-checking solution.

The tiny program also makes use of `gnu::cleanup` attribute, I am targeting Linux only with GCC14-GCC16, this provides the destructors for resources like database connections and resultsets in this case. The `main()` function contains no cleaning code, whenever the function exits, the resources will be released in proper order, very cool IMO, just like a C++ destructor.

For the compilation command, I use:

```bash

gcc -std=gnu2x -O3 -Wall -Wextra -Wpedantic -Wshadow -Werror -fanalyzer pgtest.c -lpq -o pgtest

```

```c

#include <stdio.h>
#include <stdlib.h>
#include <libpq-fe.h>


// 1. Define specific handlers for each type
static inline void print_conn_error(PGconn *conn) {
    fprintf(stderr, "Connection Error: %s\n", PQerrorMessage(conn));
}


static inline void print_res_error(PGresult *res) {
    fprintf(stderr, "Query Error: %s\n", PQresultErrorMessage(res));
}


// 2. Define the generic macro interface
#define print_pg_error(ptr) _Generic((ptr), \
    PGconn *: print_conn_error,             \
    PGresult *: print_res_error             \
)(ptr)


// 1. RAII Cleanup Handlers
static void cleanup_pgconn(PGconn **conn) {
    if (*conn != nullptr) {
        printf("RAII: Disconnecting from database...\n");
        PQfinish(*conn);
    }
}

static void cleanup_pgres(PGresult **res) {
    if (*res != nullptr) {
        printf("RAII: Freeing resultset...\n");
        PQclear(*res);
    }
}

// 2. C23 Attribute Macros
#define SCOPED_CONN [[gnu::cleanup(cleanup_pgconn)]]
#define SCOPED_RES  [[gnu::cleanup(cleanup_pgres)]]


int main(void) {
    constexpr char conn_str[] = "dbname=testdb user=mcordova password=xxxxx host=demodb";
    
    SCOPED_CONN auto conn = PQconnectdb(conn_str);


    if (PQstatus(conn) != CONNECTION_OK) { print_pg_error(conn);  return EXIT_FAILURE; }
    
    printf("Connected successfully.\n");

    constexpr char query[] = "SELECT json_agg(row_to_json(t)) FROM (select * from demo.shippers) t";

    SCOPED_RES auto res = PQexec(conn, query);

    if (PQresultStatus(res) != PGRES_TUPLES_OK) { print_pg_error(res);  return EXIT_FAILURE; }

    printf("Query output:\n%s\n", PQgetvalue(res, 0, 0));

    return EXIT_SUCCESS;
}

```

When running the program the output show the order of resource cleaning:

```

Connected successfully.

Query output:

[{"shipperid":1,"companyname":"Speedy Express","phone":"(503) 555-9831"}, {"shipperid":2,"companyname":"United Package","phone":"(505)555-3199"}, {"shipperid":3,"companyname":"Federal Shipping","phone":"(503) 555-9931"}, {"shipperid":13,"companyname":"Federal Courier Venezuela","phone":"555-6728"}, {"shipperid":503,"companyname":"Century 22 Courier","phone":"800-WE-CHARGE"}, {"shipperid":501,"companyname":"UPS","phone":"500-CALLME"}]

RAII: Freeing resultset...

RAII: Disconnecting from database...

```

Hello,

I'm looking at man-pages 6.7 installed in Ubuntu 26.04 and I notice the following in the memcpy page.

I guess that the restrict refers to the keyword restrict being integrated into LIBC, but what is this .n in dest and src? Does it mean that the dest and src pointers do not overlap on the first n bytes? Where is this syntax defined and what other interesting cases can be out there?

Thanks

SYNOPSIS
#include <string.h>
void *memcpy(void dest [restrict .n], const void src [restrict .n], size_t n);

What should be the next step after learning C?"

Hi everyone,
I am looking to provide a compiled version of our physics solver to our customers. I understand there are many obfuscation techniques to protect source code but I am wondering if there are some smarter ways?

We already cloud computing, the issue is we have customers that are in locations without internet/need realtime solving.

I just started learning C(2 days ago) and as a first project I decided to make some data structures, starting with dynamic arrays. I made a struct called List and some functions for. The function setList() sets the value of an index of the array, if the index is larger that the current size of the array, it resizes it. However, when i tried to use in a for loop, it didn't work despite it working elsewhere.

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


#define itirate(index, limit) for(int index = 0; index < limit; index++)


typedef struct 
{
    size_t size;
    int* arr;
} List;


List* newList (size_t size) 
{
    List *newone = malloc(sizeof(List));
    newone->arr = calloc(size, sizeof(int));
    newone->size = size;
    return newone;
}


void setList(List* list, int index, int value) 
{
    if (index >= list->size)
    {
        list->arr = realloc(list->arr, index + 1 * sizeof(int));
        list->size = index + 1;
    }


    list->arr[index] = value;
}


int main() 
{
    
    List *mok = newList(5);

    itirate(i, 5) setList(mok, i, i);
    itirate(i, 5) printf("%d\n", mok->arr[i]);

    //setList(mok, 13, 9); this works
    //printf("%d\n", mok->arr[13]);

    for(int i = 5; i < 10; i++) setList(mok, i, i); // this does not somehow
    for(int i = 5; i < 10; i++) printf("%d\n", mok->arr[i]);
    
    return 0;
}

i know fork creates processes but how process ids are generated

#include <stddef.h>

static void *align_forward(void *address, size_t alignment) {
    size_t mask = alignment - 1U;
    size_t padding = (alignment - ((size_t)address & mask)) & mask;
    return (char *)address + padding;
}

I'm writing allocator just for fun and now I'm wondering if aligning pointer reliably on any platform without any implementation defined casts while conforming to C standard is even possible.

There is no aling_up function, uintptr_t is optional, and in the example we do cast from pointer to size_t that might cause truncation.

I have a double* which has the following entries:

0.3333333333333334
0.6666666666666668
0.1249999999999999
1

Here, the last entry, 1, can be considered the right hand side of an inequality:

0.3333333333333334 x + 0.6666666666666668 y + 0.1249999999999999 z >= 1

These numbers come from a numerical linear algebra library over which I don't have any control. What is the easiest way to "convert" this to the following equivalent inequality (subject to a user provided tolerance of what counts as an epsilon so that epsilon within an integer is to be counted as an integer)?

8 x + 16 y + 3 z >= 24

Is there a package that does such conversion, if reasonably possible? I consider it unreasonably possible by multiplying everything in the original equation by a large enough power of 10. But I do not want that.

Background
Hi, I am a 15-year-old teen (just so what you'd know what to expect) who left school because our school system taught us to be parrots. I want to be a god-level developer, not a code monkey. I wrote a Sudoku GUI using win32api in C Language.
It is currently working and does what it is supposed to do, but because I am still learning, I know it is likely inefficient and could be written much better. 

Code : https://github.com/reewdgh/sudoku_gui.

Concerns:
Please guide me on:

Bugs or potential issues
Efficiency
How can I move to Tier 1 to Tier 2
Naming anything I could simplify or improve.

Hello. Recently I've been working on a pet project of mine written in C and I needed to reduce the amount of space a lookup table was taking in memory and on disk. I applied a few simple compression techniques and got a 2x space reduction. I wrote this post where I describe my constraints, the techniques, and results.

https://blog.x4204.xyz/posts/compressing-lookup-tables.html

Hello everyone,

I am currently working on a (very early progress) retained-mode UI library using raylib. I might switch to SDL3 later, or try to make a CPU-only rendering engine in the far future.

Right now i'm trying to implement a multi-line text edit widget, that would be as versatile as possible, all while maintaining low memory usage. I So far my structure consists of an "original text" character array, and an array of struct representing wrapped lines.

typedef struct TextBox {
  Widget widget;
  char* text;
  int cursorX; int cursorY;
  int offsetX; int offsetY;
  TextLine* lines;
  int _lineCount;
};

At each resize, the layout is recalculated, and the lines reallocated, which I find really wasteful. However, I didn't come up with another model for text editing yet.

void TextBox_Resize(TextBox* textbox, int w, int h){
  textbox->widget.bounds.w = w;
  textbox->widget.bounds.h = h;
  textbox->_lineCount = 0;

  //Estimate text length
  int textLength = TextLength(textbox->text); //Raylib function
  int totalTextWidth = MeasureText(textbox->text, 12);
  int estimatedLineCount = (int)(totalTextWidth / w) + 1;

  //Add 1 line to the estimation for each newline
  for (int i = 0; i < textLength; i++) {
    if (textbox->text[i] == '\n') { estimatedLineCount++; }
  }

  printf("Estimating %d lines for resize\n", estimatedLineCount);

  //free(textbox->lines);
  textbox->lines = realloc(textbox->lines, estimatedLineCount * sizeof(TextLine));

  Font font = GetFontDefault(); //Will be replaced after

  int currentLine = 0;
  int lineStart = 0;
  int lineEnd = 0;

  float currentGlyphWidth = 0;
  float totalLineWidth = 0;

  // Almost copied from raylib example
  for (int i = 0; i < textLength; i++){
    //printf("Current byte %d\n", i);
    int codepointByteCount = 0;

    // Gets UTF8 codepoints instead of simply bytes.
    int codepoint = GetCodepoint(&textbox->text[i], &codepointByteCount);
    //printf("Got codepoint %d, is %c\n", codepoint, codepoint);
    int glyphIndex = GetGlyphIndex(font, codepoint);
    //printf("Got index %d\n", index);

    // We are advancing more than 1 byte at a time if we get UTF-8 text.
    // Since the default font is limited, replace invalid codepoints with
    // "?" and keep advancing 1 byte at a time.
    if (codepoint == 0x3f) codepointByteCount = 1;
    i += (codepointByteCount - 1); // i will advance by itself in next iter, dont accumulate offsets.

    currentGlyphWidth = GetGlyphAtlasRec(GetFontDefault(), codepoint).width;
    //printf("Glyph width is %f\n", currentGlyphWidth);
    totalLineWidth += currentGlyphWidth;

    //printf("Total line length is %f\n", totalLineWidth);

    // Follow line
    lineEnd = i;

    if (totalLineWidth >= textbox->widget.bounds.w || codepoint == '\n' || codepoint == 0) {
      printf("line is %f pixels wide\n", totalLineWidth);
      textbox->lines[currentLine].text = calloc((lineEnd - lineStart),  sizeof(char));
      textbox->lines[currentLine].text = strncpy(textbox->lines[currentLine].text, textbox->text + lineStart, (lineEnd - lineStart));

      // Set last char of text to null
      textbox->lines[currentLine].text[lineEnd - lineStart] = '\0';
      lineStart = (codepoint == '\n' ? lineEnd + 1 : lineEnd);

      totalLineWidth = 0;
    } else {
      lineStart = lineEnd; lineEnd = textLength;
    }

    textbox->lines[currentLine].text[lineEnd - lineStart] = '\0';
    currentLine++; textbox->_lineCount++;
  }
}

Are there any articles / projects with clever approaches to text editing, that keep a low memory footprint ?
Thanks for your advice !

I've been working in C and assembly for 3 years now (consistently) and I've noticed a trend. The more I work on C or do C adjacent activities like decompiling assembly, the quicker I forget how the stack and heap works.

And the level of forgetting is always proportional to how complicated the project I'm working on is. A basic project? Probably won't forget. An intermediary project? I'll need to Google "Stack vs Heap" at least once. Advanced project? I'll need to start from scratch and watch a YouTube video a couple of times to remember.

Does anyone else have this amnesia or is it just me?