Okay, so this is cool, but also vibecoded by someone who just does frontend. I totally support AI development, but the first commit was 4 days ago and it's entirely written by claude. The UI looks like "the style that that AI comes up with" turned into a C framework.<p>I don't want to discourage this kind of experimentation, but I also question how much of the last 20+ years of UI and C knowledge was not used in the construction of this project. Also, do I want to build a kanban board in C? Unsure.<p>Just take care when evaluating this for actual usage.
People (rightly so) complain about the wastefulness of datacenters and AI mostly due to the pollution, and "projects" like this one not only do not justify that pollution, but worsen it.<p>We have GPUI, we have web components, we have Clay UI. No one needs a C UI library.
The thing with these kind of projects is that... What value do they really bring to the table? Because if it's so easy to come up with something like this (and arguably easier over time), then if I need a UI toolkit and components for my app, I can just prompt them right away to obtain something like this with minimal effort. Plus, adapted to my needs, my code, my platforms and language. UI/UX done right is still a dance between design and engineering. But I'm not sure these libraries do solve anything meaningful today that is worth the abstraction and dependency.
I am pretty sure that, even though this project is generated by AI, there will be a large majority of quicks and edge cases and bugs, just like as if a bunch of people would have written it. It's just that the initial bulk of the code was produced in a fraction of the time. All those bugs, quicks and edge-case still need to be resolved (if you were to actually use this). If you prompt your own version of this you just end up with your own set of bugs, quirks and edge-cases. The nature of software hasn't changed, just the speed with which we produce it.
I promise you, this project has not addressed the quirks and edge cases. I don't think many of these components have even been tested by a human, because there are glaring omissions that you'd see if you just played around with them for a minute.<p>Do you think that this person is going to stick around and fix those issues, or just move on to the next impressive project in a week?
~200 USD in 1mo of claude, and 4 days of developer time -- call it 5000 USD
<i>How</i> does a five-day old C project have 611 stars? Hard to imagine that many people are writing user interfaces in C...
It looks like ShadCN-UI which AI likes to use.
Some projects are worth it just for the rebrand.
I click around on mobile nothing happens, vibe coded trash. I’d spend 10 minutes comparing it to Clay but it’s not worth it I already know the result. The problem with this kind of projects is they expire very soon, the least the effort the least the value
More like custom UI components. Native would have been if you had wrapped e.g. Cocoa NSButton on macOS and Microsoft.UI.Xaml.Controls.Button on WinUI.
Native is one of those words that means different things depending on context and your background. For me, native means actual binary code running on the machine, not through a JVM or V8 or anything of the sort.<p>In the Apple world, Native usually means using the system UI components and the Apple guidelines.
There are some libraries that use native widgets on each platform, e.g. libui-ng. Although the issue with things like this is that you aren't going to be able to use all of AppKit, and you get forced into the lowest common denominator expressable by all platforms.<p>A good middle ground might be having platform-specific pieces but expressed using a more standard domain-specific language. E.g. technically you can already wire up GUIs without interface builder but it's quite verbose. There should be some simpler way to express layout constraints and have button callbacks.
We need a HN min-release-age flag for posted projects.<p>Or some flag to ignore users that post these types of projects often.
The site and community should be structured such that what it values discussion for naturally bubbles up, not different opinionated flags for each interest, fad, or pet peeve.<p>Though, funnily enough, this kind of info and more is extremely easy to add to HN via a vibed extension. At this point, mine just stops HN from loading completely and constructs its own page (with a proper dark theme and the information I care about).
Any community needs not only a bubbling up of good content, but also an immune system against bad content. Otherwise in practice you become inundated with spam and noise.<p>The reason for this is an effort asymmetry: casting upvotes is easy, and most people do it without much thought, whereas determining that something is spam or misinformation requires looking a lot more closely.
I usually don't post a lot, but to be honest: the components demo definitely caught my attention (I know it's coded by Claude)<p>It's not my project but I will definitely give the library a try.
Surprised post downvoting is not a thing yet.
Since most of my code for work is AI-generated now, I recently started a small side project in part to continue practicing coding by hand, and decided to use C. There's something nice about using a language that's simple enough that I could write/maintain my own compiler if I really had to.<p>I'm really curious how secure C software would be if reviewed by AI and run exclusively in a WASM runtime.
C increasingly makes sense for compile times if you can have a separate Fable pass on memory safety, etc.
Assembly is increasingly making sense for compile times if you can have a separate Fable pass on code correctness, etc.
C has always made sense for building software as long as you do a memory safety pass.<p>The tools have gotten fancier, for sure, though.
<a href="https://fil-c.org/" rel="nofollow">https://fil-c.org/</a> exists
I'm observing the opposite phenomenon. I recently vibecoded (with supervision) a 25k-line Rust codebase that takes 15 seconds for every build. If I were writing that by hand, a 15-second build time would drive me crazy and I would stop working until I could find a good way to speed it up. With vibecoding it barely matters, because the interval between builds is much longer and the agent (Opus 5.5) spends most of its time thinking or running tests. Unlike me, the agent rarely makes the kind of trivial mistakes that require rebuilding multiple times in a row.<p>For larger codebases, things might be different.
Leaving memory safety up to a model is wild. That's not a sound guarantee of safety for anything.
This is amazing, finally a good looking UI framework for a low level language! I will be looking at this next time I need a little UI, since it's nice when you can make an app that has a UI and it's distributed in much, much less than 1MB rather than 300MB as most Electron apps.
Looks like ShadCN. That too in C. It's really really elegant.<p>EDIT: It's immediate mode.
This is a major spillage of CUI
this looks really sweet actually. didnt dig into the backing code yet but the examples look really nice and clean to implement a UI with. well done.
Clearly vibecoded, but it looks really nice. The widget id generation seems pretty naive, I wonder how well it handles dynamic UIs.
This looks like built by someone raised exclusively on web and touch technologies, forgetting that both are the results of constraints. The web was not meant to be a UI platforms and have poor primitives, and touch devices lack precise positioning and a physical keyboard.<p>Take the chips and rating as an example<p><a href="https://yappologistic.github.io/CUI/#/c/chips-and-rating" rel="nofollow">https://yappologistic.github.io/CUI/#/c/chips-and-rating</a><p>It’s purely aesthetic as functionality (and ux) wise, chips are not different from checkbox with labels and rating is just a discrete slider.<p>And as I thought, you can see the duplicate code for switch and checkbox here.<p><a href="https://github.com/yappologistic/CUI/blob/f1202e6d98cdc297f901d16b674259c6a646aa80/src/cui_controls.c#L141" rel="nofollow">https://github.com/yappologistic/CUI/blob/f1202e6d98cdc297f9...</a><p>People do need to differentiate between UX primitives and something that just looks different.
Design is essentially a clone of egui in C.
Since AI has removed the bottleneck of writing code, so I understand why not go directly C. This could bite back sooner or later.
Can't wait for RUI, the vibecoded Rust version of this vibecoded C project.
One of the most hideously ugly C codebases I’ve ever laid my eyes on. I don’t even care if it’s bug free. What value does this add to the programming community? A “library” generated by a morally bankrupt megacorporation’s plagiarism machine. Good job learning nothing, contributing nothing except another shadcn looking UI shitkit, and further training the beast that will eat you alive one day. I will now use this opportunity to promote Clay (not mine obviously), which is absolutely loaded with heart and soul, and is a beautiful piece of engineering: <a href="https://www.nicbarker.com/clay" rel="nofollow">https://www.nicbarker.com/clay</a>
The acronym collision is entertaining. I now want to use CUI to mark up my CUI.
Looks lovely, but without long term support and hostory, I wouldn't touch it with someone else's long stick.
So funny seeing these kinds of frameworks being vibe-coded. I can tell the author has never used the zillions of frameworks the LLM was trained on. Writing (and maintaining) this kind of code is absolute nightmare fuel.<p><pre><code> bool narrow = cui_viewport_size(ui).x < 760;
cui_row(ui, .width = CUI_FILL, .height = CUI_FILL, .align = CUI_ALIGN_STRETCH) {
if (!narrow) { sidebar(ui, s); cui_separator(ui); }
content(ui, s, narrow); /* a menu button opens the drawer when narrow */
}
cui_sheet(ui, "Menu", &s->drawer, .side = CUI_SIDE_LEFT, .size = 280) { nav(ui, s); }
</code></pre>
There's a reason QT uses XML for their layouting, there's a reason people prefer Tauri + Vue/React, there's a reason Swift uses declarative paradigms in all their UI code. It's not that you <i>can't</i> build good UI frameworks in low-level languages; for example, I think Go's Fyne[1] is a pleasure to use. But people actually used their brains when designing that framework, as opposed to "hey Claude build a UI framework in C, make no mistakes."<p>[1] <a href="https://fyne.io/" rel="nofollow">https://fyne.io/</a>
That looks pretty readable to me. Somewhat noisier than SwiftUI due to all the repeated "cui_", but not much. I've seen far worse.<p>I would be more concerned about the opposite problem: the fact that it's apparently reactive and thus inherits the same performance pitfalls as every other reactive UI framework. Retained-mode UI is much uglier (at least if you build the UI in code) but doesn't have these issues.<p>edit: actually it's worse than reactive, it's full immediate-mode render-everything-every-frame.
<i>There's a reason QT uses XML for their layouting</i><p>You're on shaky ground using xml for ui layouts as posterchild for good developer ergonomics.
I think you are missing the point entirely.<p>The use of C, in that case, was likely made for performance reasons and avoiding dependencies.<p>The author added dozens of complex widgets in a few days, AI driven of course. The intended audience is not manual coders, you would show some examples to the clankers and ask for you UI and custom widgets.
Can you please prompt your agent to generate a C++ binding?
You know what this needs now? A Lua REPL.
Any pre-built examples? Even if it's something like a calculator.
CUI - Controlled Unclassified Information.
<p><pre><code> $ tree lab
lab
├── BUI
├── CUI
├── GPUI
└── TUI</code></pre>
Yeah I just did a double take at my desk reading this
Yeah. Not good acronym for this.
Looks great, but node editor is janky on mobile.
I wonder how this does with embedded devices. Would be cool to get an ESP32 with smooth animations/nice UI.
I’ve also spent the last couple of weeks vibe coding a component-based UI framework for C. My target is embedded hardware with 2 * 300mhz ARM 32 CPU, and a Nintendo 3DS like OpenGL ES 1.1 GPU from DMP: Fujifilm cameras from 2013-2016 like the X70, X-E2, X-T1, X100T. It’s a bit faster than iPhone 2007 on CPU side, and slower on the GPU side due to needing to copy from GPU back to main memory for scan-out. It’s funny how these things seem to come up and then everyone’s doing it.<p>I didn’t see the code here because I couldn’t find an easy link to its Github. My UI framework i’m calling FocalUI. We do layout and basic geometry with a fork Clay where we added “layer” and “focusable” markers to Clay elements. Instead of drawing immediate mode, we store a list of draw commands and layer geometry in a CoreAnimation-like tree. The renderer composits the layer tree and renders to OpenGL, and we use damage tracking to copy just the changed pixels from the GPU back to the camera’s framebuffer for scan-out.<p>It’s been a huge effort to add touch inertial scrolling, spring animation, navigation effects etc at 55hz to this device that before only did d-pad nav at 25 Hz, but things are starting to shape up for a release this week :)
Shame to put effort into encouraging more C code. All C code needs to be torn out by the roots. I don't care how carefully crafted it is and how many Fable passes have been done, it is inherently unsafe.