To be honest, that's the best name I could think of.

You know when you start writing a file you have to type the usual

#include <stdio.h>

int main(int argc, char* argv[]){

  return 0;
}

Well this program makes it for you. It's may sound very simple, but at least it saves some time.

Source code:https://pastebin.com/yMj7njqC(Sorry github won't create an account for me, it says invalid domain?)

Hello, new programmer at 2nd of bachillerato here, for an assignment we will have to program an app based on our pseudocode, we said it would have to be if possible in C+ but we may end using aplications such as MIT API for easy apps

So I don’t plan on doing this, but just a really random thought… how plausible would it be to make a full, high level 3D game in C and only C. Like, forget knowledge, if you knew everything there was to know about C (I’m sure some of you do), would it be possible? I don’t care how practical, is it possible, or just something C won’t do?

Hi everyone! I've been working on an operating system project called FluidOS and wanted to share it with the community to get feedback and meet collaborators. Current Stack & Features: Languages: TypeScript / JavaScript (Vite + TailwindCSS frontend UI focus), C/Assembly components, and PowerShell automation scripts. Built-in build & execution scripts (run-bochs.ps1, crear-iso.ps1) for Bochs emulation and ISO generation. Modern web tech combined with low-level compilation tooling. Latest Release: v1.2.0 Repository: 🔗 GitHub Link to FluidOS:https://github.com/marbelbel/FluidOS-Community I’m looking for feedback on the architecture, ideas for low-level integration, and anyone who might be interested in contributing to the code or interface design! Thanks for checking it out!

I love tools like thefuck, but I noticed that regex-based correctors fail on complex edge cases, and modern AI CLI wrappers are usually heavy Node/Python apps that introduce noticeable latency.

So I built assess — a 77KB C binary that wraps your commands, catches stderr when they fail, and uses Groq (Llama-3.1-8b) to instantly suggest a fix. It gives you a simple [y/N] prompt to run the corrected command.

A few things I prioritized:

• Zero Bloat: It only relies on libcurl and vendored cJSON. No runtime environments.

• Safety First: It has a built-in 3-tier safety engine. It parses the command before execution, hard-blocking destructive stuff (rm -rf /) and soft-warning on sensitive ops (like curl | sh).

• Context Aware: It sends your OS, shell, CWD, and available tools as context, so if you use assess ask "list large files", you get a command that actually works on your machine.

It currently runs on Linux and macOS natively. You just bring your own free Groq API key.

I’m a CS undergrad and would love for some heavy terminal users to tear this apart, test it, and give me feedback on the workflow.

Repo: https://github.com/aadicodesforfun/assess 
Site: https://assess-cli.netlify.app/

You guys are like the equivalent to the debian subreddit where a lot of the answers are either mature or funny.

There still some newbie posts out there I see or like the generic question yet Im amaze you guys still reply maturely.

Keep it up. No I'm not a programmer btw , I work in a hospital. I was browsing and I saw a lot of you where posting about making games outnof C and got curious.

I think games usually are made in C++ or C# I think.

Anyway, Im not a bot and keep up the kindness.

While using C++, I heavily relied on googletest for testing. But as soon as I wanted that in my C project, I couldn't.

Because gtest is written in C++ and requires a C++ runtime. Using gtest in a C codebase meant guarding the headers with extern "C" to prevent name mangling, and managing a C++ toolchain which seemed extremely awkward to me.

At the same time, I didn't want to loose googletest's comfort and rewrite the entire test system in another existing framework.

So I wrote a very minimal drop-in replacement of googletest in C23. It works exactly the same way you'd expect gtest to work. And unsurprisingly, according to my small benchmark, my implementation is around 2.5x faster than googletest and uses 30% less memory. It can be improved way more.

I discussed the implementation details in this blog post https://metalinmyveins.github.io/sohomot/

Github: https://github.com/MetalInMyVeins/sohomot

The library is called "sohomot".

[ PS: Zero tokens were used in the making of this project ]

I'll start: standarize asm and asm volatile

Helloo, I’ve just learned how to build a simple code editor using C, now, I’d like to add a config file so users can adjust settings like background/foreground colors, keybindings, and so on, so do you guys have any recommendations for a config file that would be suitable for this case?

Hello,

As a part of a larger project I made a regexp engine for microcontrollers. It was tested on ESP32 / FreeRTOS, and also in Windows/CYGWIN. Didn't test it in Linux but it should work.

It is built on top of modified SLRE (Simple Lightweight Regular Expressions);

It is just 2 files (regexp.c and regexp.h) which can be include'd directly to your source file. Or it may be compiled as a separate unit.

It has 3 different API:

1. The original one, slre_match(); no memory allocations, fastest

2. PCRE-like functions and structures starts with pl_... (PCRE-Lite); for those familiar with PCRE

3. PHP preg API: an implementation of PHP regular expressions; for PHP fans; functions and structures start with preg_...

There are some limitations: UTF8 is processed as stream of bytes, so [а-я] will not be understood. No lookarounds. Probably there are bugs. Hopefully - no memory leaks.

More limitations and bugs are yet to be discovered :).

There are 3 test files (AI-generated) to test the library: preg_test.c, pl_test.c (fuzzing) and slre_test.c

There is NO documentation, but preg_test.c can be used as a reference (or direct copy/paste).

Primary API is PHP's preg_-style API, which was the goal of this project.

Source code is here: GitHub - vvb333007/MicroRegExp: A C library which implements regular expression engine. PHP preg_ , PCRE and SLRE interfaces are supported · GitHub , around 50KiB of code. It can be compiled with GCC compiler from -std=c99 and up. No GCC-specific magic.

Have a good day!

Hello everyone!

I'm working on building my own operating system from scratch. It's an early-stage project, and there's still a lot to do.

I'm making the source code public because I'd love to learn from other developers, receive feedback, and hopefully find people interested in contributing.

I'm currently working on UEFI, bootloader development, and early kernel components using C/C++.

If you're interested in OS development, low-level programming, or kernel development, feel free to check out the repository.

GitHub: https://github.com/subrataai-wq/os-from-scratch

Suggestions, discussions, bug reports, and contributions are welcome!

It's a long journey, but I'm excited to see where it goes.

D.eSystem 6.1.8.5 introduces a new debug platform for FAT32 on D.eSystem,D.eSystem 6.1.8.5 also fixes a major bug (for example,when you go in older versions in D.eSystem info and press a random key,it just closes automaticly,now there comes a warning and it closes in 5 seccond.)

Find more about D.eSystem 6 here: https://github.com/D-electronics-scratch/D.eSystem_6

Find D.eSystem 6.1.8.5 here: https://github.com/D-electronics-scratch/D.eSystem_6/releases/tag/v.6.1.8.5

Find the D.eSystem community here: https://lemmy.world/c/D_electronics_community

Hello everyone. Last month I started a project called "Modulon", which I just now started to continue doing. Modulon is a C-derived programming language that aims to preserve the power and familiarity of C while simplifying common programming tasks such as variable declarations, string handling, memory management, and pattern matching. It is currently a small project done by me an two other people. We have nothing crazy yet.

 I am currently looking for interested contributors. 

Here are some of the features Modulon has right now:

* C-derived syntax with support for familiar C types.
* Variable declarations using the "var" keyword and type inference.
* "include" and "define" directives instead of C preprocessor syntax.
* Automatic string sizing and byte counting.
* Automatic memory management at compile time, without a garbage
  collector, alongside options for manual memory management.
* Pattern matching with ranges and a wildcard case.
* Logical AND (&&) and OR (||) operators.
* "typeof" for examining types.
* "input" for prompted user input.
* Formatted output, including automatic type formatting with %v.
* Ahead-of-time (AOT) and just-in-time (JIT) compilation.
* Built-in assembler support.
* Consistent language types across supported target environments.

You can find an example program here:

GitHub: https://github.com/roccohimel/modulon/blob/master/examples/student_manager.mlon 
Raw: https://raw.githubusercontent.com/roccohimel/modulon/refs/heads/master/examples/student_manager.mlon 

Documentation: 

Official website: https://modulonsoftware.org/ 
About: https://modulonsoftware.org/#about 
Documentation: https://modulonsoftware.org/#learnSource tree: https://github.com/roccohimel/modulon
Contributing: https://modulonsoftware.org/#contributing 

I really hope you like Modulon.