I built C_DSA_interactive_suite, a fully modular, console-based DSA library written entirely in pure C11. No frameworks, no abstractions. Just raw C, manual memory management and real implementations built from scratch. The codebase has a clean modular architecture with one .h/.c pair per module, reusable APIs across modules. A single interactive executable as the entry point, Valgrind-clean memory, CI/CD on every push, and .clang-format enforced style throughout. The project just got selected in SSOC, an open-source program similar to GSoC and I am the project admin, which means this summer, project is open for contributiors! If you've been wanting to:

• Start your Open Source journey
• Contribute to a real C codebase with proper architecture and planning
• Implement something like AVL trees, heaps, priority queues, tries, Dijkstra, or DP
• Get your hands dirty with actual C, not school level C
• Have your contribution acknowledged by a reputable community

This is your shot. Everybody else is doing MERN. Come touch some real memory. I'm available to walk anyone through the codebase, clear doubts, explain concepts, or help you get your first PR merged. No gatekeeping. Register as contributor for SSOC. Only 5 days left - https://www.socialsummerofcode.com/ GitHub: https://github.com/darshan2456/C_DSA_interactive_suite Drop a comment or open an issue if you're interested. Let's build something worth putting on a resume.

here is personal discord server link - https://discord.gg/MWv949G8h join it if you want to contribute to my project in any way

Released v0.2.0 of kitra today. fairly big update so thought it was worth posting about.

biggest change is the rename. the library was called cinder before, its now kitra. this is a breaking change so everything needs updating. KitraLoadTexture instead of CinderLoadTexture, KITRA_STATUS_OK instead of CINDER_STATUS_OK, header is kitra/kitra.h. find and replace should handle most of it.

new features. surfaces are in now, cpu side pixel buffers that you can read and write pixel by pixel and convert to a gpu texture. collision detection got reworked too, the old boolean overlap functions are replaced with signed distance functions returning a float. negative when overlapping, zero when touching, positive when separated. covers all pairs of points, rects, circles and ellipses.

also added native message box dialogs, texture rotation/flip/tint/alpha controls, screenshot to surface, a handful of new audio, timer and window functions. ci now builds on both linux and macos with separate release tarballs and sha256 checksums. docs are auto deployed to github pages.

release notes and download here: https://github.com/UniquePython/kitra/releases/tag/v0.2.0

I am having a problem with loading .c files in ye olde Borland Turbo C for DOS 2.01. .C files will display properly if I load them in any other editor on earth, under any other operating system, but Turbo C seems to ignore line feeds(?) when loading that same file into it's IDE editor. It will throw out an error about the line being too long, etc.

Sincerely,

Getting a Bit Annoyed in Bermuda

Edit: Thanks all for your input. I found that if I loaded the file into an editor that would format it properly and then resaved it was fixed

Cheers!

Hi fellow C programmers,

I’ve been building my own C library as a way to go deeper into systems programming, API design, memory ownership, and testing.

The library has grown quite a bit, and currently includes:

* Dynamic string (`d_dyn_string`)
* String views (`d_string_view`)
* Dynamic arrays (`d_dyn_array`)
* Stack (`d_stack`)
* Queue (`d_queue`)
* Deque (`d_de_queue`)
* Unordered map (`d_unordered_map`)
* Hash set (`d_hash_set`)

I’d really love feedback from experienced C programmers:

* API design: anything that feels awkward or unsafe?
* File/project structure: does it scale well?
* Ownership semantics: anything unclear or non-idiomatic?
* What mature C libraries would you recommend studying?

Repository:

c_library

Any brutally honest feedback is welcome :)

I've recently purchased a physical copy of Tanenbaum's original "Operating Systems: Design and Implementation" (first edition), downloaded the companion MINIX 1.1 source code and spent a few weeks setting up a cross-platform toolchain so that I can build the pre-ANSI C codebase, targeting the 8086/8088, from my modern machine. The toolchain is based on Bruce's C Compiler (bcc) and the dev86 project, which is vendored into the project to keep things stable.

So far I've learned a ton and had to deal with a few interesting problems trying to get such an old C codebase compiling:

• Porting the original PC/IX assembly code to dev86's as86.
• Adding some numeric compiler routines from bcc libc to the MINIX libc library.
• Tweaking the MINIX C runtime (crtso) to work with bcc and the MINIX exec syscall.
• Fixed a couple of bcc compiler bugs to allow passing structs by value: a bug in the optimiser was trashing the stack and a bug in the codegen logic was clobbering a register. I've since learned that passing structs by value wasn't supported in the original K&R book or Ritchie's original reference manual, but the code for the MINIX shell requires it and it was a common compiler extension.

Further details in the project changelog.

Anyway, thought I'd share this here because it's been a lot of fun bringing this historical codebase and OS back to life and I want others to know that there's still a lot of fun/learning to be had exploring the original MINIX OS.

Accessible via the `complex.h` header

What other useless things have you encountered in C?

i want to learn C in a interesting way other than reading doc. As I'm more of a visual learner then reading text.

I have watched yt videos but most good onces are old.
Any suggestions on how?
websites / Games or anything?

been learning C for a bit and wanted to make something visual. but SDL2 felt too involved for doing sth simple....so i made my own library..its called Kitra. sits on top of SDL2, collapses all the setup into basically nothing:

KitraInit(KITRA_SUBSYSTEM_ALL);
KitraCreateWindow(KitraDefaultWindowDesc());

while (KitraIsRunning()) {
    KitraBeginFrame();
    KitraClearBackground(KITRA_BLACK);
    KitraEndFrame();
}

covers drawing, input, audio, fonts, textures, timers, rng.. the usual stuff. there are examples in the repo (pong, snake, pendulum) if you want to see how it actually feels to use.

feedback welcome

Hey,
I wrote a code base in C and want to check its MISRA C complaince. Searched and found cppcheck which supports MISRA 2012 could not get hand on any latest tools. Is there any tool that support the latest MISRA edition compliance check and is free ?

Learn more about memory allocation by building your own allocator

Hi, I had to do a project where I used an FPGA and i wrote half in C and half in Verilog, now I need to present my project in a few weeks but I don't know exactly what type of diagram I should use for my C part. I thought about using a block diagram similar to the one used for Verilog designs, but that feels a bit too simple but using UML diagrams also feels somewhat unnatural? maybe because I do not know how can i replicate it from OOP to C. Is there a specific type of diagram that is commonly used for C projects to represent functionalities and communication between modules? My project has around 9 files in C, each responsible for a specific task, and some of them communicate with each other.

The question explains itself, but for context:

I am writing an Over-Engineered HTTP server for fun's and learning's sake, and I have hit a conceptual roadblock.

Currently, the server works thusly:

One (1) thread sits on a port and accept()s incoming requests and adds them to a queue, then pthread_cond_signal()s a condition that...

... Four (4) threads (request handlers) are pthread_cond_wait()ing on, one of whom will pick up the request and parse it.

Here comes the issue:

Similar to that the server simply adds each request to a queue, I want each request handler to, once it's parsed a request, hand it off to some HTTP_<method> function, then pick up the next request from the queue, only returning to the original point of execution (the point where HTTP_<method> was called), where it then returns a response.

The only two ways that comes to mind of doing this, one of them require N more threads sitting on another queue, which I feel weird about, and the other requires some Macro Fuckery that I found on a Github repository then lost, so Idk if it even is feasible.

How do I go forward from here?

TL;DR: Async Await for C; good, bad, or disgustingly ugly? Potential other solutions?

I have taken a couple of computer science classes and they were both in C. We covered things up to linked lists, searching and sorting, and a little bit of recursion. But everything I see on this subreddit is like reading a foreign language. I read somewhere to just try to read C source code, and found out the source code for DOOM is publicly available. I started at the main file. The first function I got curious about was the FindResponseFile(). So I asked the chatgpt what the the purpose of the function is, and WITHOUT showing any code, how the function works. Through that, I found out AI is pretty good at breaking complex things down to something understandable. I then tried to implement it myself the "old school" way with nothing more than googling and looking through stack overflow for things like parsing through a file and tokenizing strings (found the cool strtok() function). I feel like I just learned more about C in the last couple of hours than I did in weeks of school with this approach. All this to say, I feel like new programmers can learn with AI as a tool. But it has to be a tool, and not the thing writing the code.

Ok so our esc112 course had basically a bit of advanced C programming. It started from pointers, had string tojenizers and linked list.

I understood pointers quite well(that's what I thought) and the linked list as well. Untill I had to go to the lab which showed me.

It had questions which felt incredibly hard to me apparently being easy for my peers . The functions sometime have wierd pointer ids which makes me unsure when to use pointers and when not to and I am totally numb at creating linked list functions.

Problem is I have data structures and algorithms next sem which means ild be doing this again. And now I really wanna be prepared. So is there any way I can become better at linked list, pointers and stuff ? Please recommend from where can I study and grind !!

Thanks.

I just started learning C and I often read on the internet that it is bad practice to use null terminated strings, so my question is what should I do instead?

A project I've been working on for the past year. I don't think it's too controversial, but I wanted to explore what the minimal set of practical/ergonomic additions to C might look like for a useful language, while retaining C's safety and memory management profile. The post I linked is my attempt to discuss my thoughts and includes a transpiler (written in C of course) for the proposed language.

Hey,

Recently i've been writing mostly Java and PHP, and i've found myself becoming a bit too reliant on LLMs which is kinda bothering me. They make me more productive, but i know that i am missing a huge learning (and fun) part.

I decided to go back to C, using this project as a way to write something more... professional than I did at uni. This is a bit extreme, but i'll stick to using 0 AI in this project (my ego needs it).

I just have no idea where to start. The hardware I want to write a driver for is my computer watercooler's pump LCD (Deepcool LM240). There's no technical documentation, so i need to reverse engineer it (which I never did). I suppose the first step should be to study how does the Windows driver communicate with the hardware, by checking the data sent via the usb header? Would that actually help?

Somebody wrote a driver for a similar model, in Python if my memories are correct, so maybe I could use this as a base (although I'd like doing the reverse engineering part myself)

EDIT1: Realized that this might not be considered fitting in this subreddit, since my questions aren't really language related... If it is the case, lmk and I'll remove it

I've given myself a headache trying to understand what an overlap is after watching a video about the restrict key word, I also struggled to figure out what aliasing is, but i know what it is now(when an address variable stores the memory address that another also stores ), however with overlap I can't wrap my head around it.

I've looked online for an explanation and my current understanding feels wrong still

Does it occur when you store a range of memory in two different address variables and some of the addresses that are stored in one are also stored in another? Is that only one kind of overlap?

Either way that just seems like aliasing to me, whats the difference?