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.
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.
Just take care when evaluating this for actual usage.
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.
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?
> there are glaring omissions that you'd see if you just played around with them for a minute.
That was more or less the point I was trying to make. You can vibe-code your own variant of this project (as the poster I was replying to suggested) but you run into the same problem that you need many more iterations of refinement. If we think that everyone is simply going to vibe-code their own UI frameworks (or whatever) going forward then I think that is a wrong assumption. The nature of software development hasn't changed, just the speed at which we can produce it.
This is just a comment in general, not specific to the project posted by OP.
This is a question that pops up all over the place these days. I can offer one answer.
System design is principally a process of identifying the best possible points at which to decouple the components that will make up the system. A clean design means that components can be swapped out for alternatives easily. Messy designs result in interlocking complexity.
Structuring your components as a general-purpose re-usable library forces you to consider how it is decoupled from consumers. If you do a good job designing it, it should be usable by all sorts of consumers, so you might as well make it a standalone library.
To a first approximation, I think this process of identifying clean decoupling points is the main thing that humans still need to babysit their agents over.
Very little. The motivation of contributing the open source is almost never a product, it is the feedback loop of work and achievement. Nobody will contribute to this kind of thing, because there is no feedback loop here.
It has no value, and you can tell basically immediately.
People are becoming extremely lazy and shipping the first slop the model generates because they get a rush from putting their stuff in tot he world as fast as possible.
However, I would bet significant money that all the projects like this (where every aspect has hallmark slopisms (the vibe interface design, the copy) will lose out to projects that are also heavily AI coded but that took the time and care to actually polish and differentiate themselves and thus are later to the game because they shipped after a few weeks or a month of work and refinement instead of a day.
AI can save you a lot of time but it can't save you from your own lack of restraint and your inability to discern and be an objective judge of the value your thing will have to other people. For software, mere existence is no longer sufficient anymore. Anyone can generate whatever you made instantly if you put zero effort or discernment into it. This is why so many of the Ainfluencers are emphasizing "taste".
But even taste won't save you on the end either, since anyone can clone your stuff as soon as it ships.
I personally think the future of software is probably just two extremes:
1. Personal dinky vibe coded apps that all have their individual creator as the sole user.
2. Large scale apps that don't work without significant marshaling of hard physical resources (e.g. LLMs themselves).
All the middle bits, user applications that target a specific problem space but that run locally and/or don't need legions of data centers and networks to run, will probably just die eventually. Maybe a couple of established apps will stick around in business contexts because employees all using their own personal apps and workflows causes too much coordination overhead, but at the consumer level I fully except everyone will be just vibing their own stuff pretty soon here.
I doubt it, as the principle of "garbage in, garbage out" still very much applies to LLMs. With or without AI, I'm not so naive to assume I'm going to quickly produce better software to solve well-established problems than others, with access to the same tools, who have put more time and effort into producing substantially similar software.
For specific and uncommon use cases? Sure. For something as generally applicable as a photo editor or a general purpose OS? Not a chance.
This is something I'm seeing more often... vibecoded is starting to mean somebody just delegated their thinking to AI and whatever AI spit they just shipped blindly.
I think this is quite different then what I'd call AI-assisted coding, in which the engineer is still in the reins and you can see, even if you see the tales of a lot of code in short time, that the code has actually been looked over and polished by a human.
There might be a place for vibecoded software where only the outcome matter and the code is soft of disposable, but a library or a framework doesn't seem to be the place for that.
Yea, there's some nuance here. If you're a senior engineer in the pre-LLM world, you're likely spending more of your time guiding a team than you are writing lines of code. Perhaps you're writing prose for code review guidelines and guardrails around architectural patterns, with trust that this is followed and propagates to the org. Perhaps you're giving guidelines that anything that implies a business-level decision needs to be escalated and have a rollout plan, not just hardcoded.
The question is: if you're doing this same thing, but with LLMs as your "reports," is it vibe coding? The term was once an epithet, but I think it's expanded to refer to the technique of not living in an IDE, not the objective function.
If your objective function places an emphasis on maintainability: vibe coding can be a positive. If not: it can be a source of great pain. As with many things, it's the wielder, not the technique.
> ... but also vibecoded by someone who just does frontend
This is the kind of thing I can't understand. They're trying to solve a problem they don't have. Assuming other people might need it, without understanding anything about that domain.
There's a thing that people who are infatuated with AI can't understand: anybody else has the same power as you! The old entrepreneurship-like ideal of trying to create something new just for the sake of innovation doesn't work anymore. Innovate on something that solves a problem you have, for you. Otherwise it's just slop, introducing chaos to system, increasing internet entropy.
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.
We have GPUI, we have web components, we have Clay UI. No one needs another C UI library.
Well, actually they do, but the LLM wouldn't know why. You gotta have used all these to figure it out, and then spend months wondering upon a better design, researching old experiments by random people in archived repos for inspiration. LLMs are useful only for that last part, quickly comprehending a strange repo you found from 15 years ago.
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.
In the Apple world, Native usually means using the system UI components and the Apple guidelines.
Not the best title. It is not "for C", but in C. And currently useable on desktop + web but after looking at the project I think it will quickly be ported on mobile etc.
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.
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.
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.
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.
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 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
Yes, and? As the cost of code generation approaches zero, this starts to make more sense, especially if you do have mechanisms in place to ensure safety and correctness.
I did an experiment a couple weeks ago of having Opus 5.5 translate an MP3 decoder from Rust into Cortex-M33 assembly language, both raw asm and symbolasm. The code was 3x smaller and ~1.5x faster than Rust -O3. These seem like gains that are worth it.
As the cost of code gen approaches 0 the cost of the test suite actually grows. Not just in definition, but execution.
An MP3 decoder for a single target doesn't really run into that complexity, a UI components library for (Linux, Windows, macOS) * (x86-64, ARM64) suddenly has a 6x multiplier on what was already something with waaay deeper dependencies and integrations than MP3.
At least that's what I've noticed vibing my DE without external libraries. It went really fast when the complexity was small because most of the work was in adding code. Then it started taking longer to build and test, even with optimized builds and tests, than it took for the AI to do its part.
Yes that makes sense, but if you're iterating on software then I think C will generally win due to its ability to compile cross-platform until you want to build a "release" which you could do by having Fable translate it to ASM at that point.
Did you have it go directly to asm or emit the assembly from the Rust toolchain and then contract that? For small stuff, I have been having it write directly, or larger pieces I am having better results via contractions.
I should add, part of the experiment was to test whether having variable names and (C style) types would help the LLM. For a task of this size (about 1.5 kLoC Rust, 3k insn asm) it was inconclusive, but for larger projects I suspect it would make a difference.
And the plan for symbolasm is to move past C style types into Rust style and maybe dependent typing, specifically to facilitate automated proofs.
But Rust is unreadable compared to reasonably well written C. It matters if you care to read any of the code yourself and/or want to retain the ability to make manual changes. There is a reason C hasn't been displaced after all this time.
What an odd statement. Unreadable code is unreadable regardless of language. I’ve seen my fair share of unreadable C. Indeed Rust can be ugly in advanced use cases with heavy syntax but C’s simpler syntax does not mean it is always readable either. Hell, I've seen unreadable Python and Lua!
C has in fact been displaced in many places. Just because it survives in a few holdout contexts is a historical artifact more than a testament to the language.
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.
So, i downloaded it, built and tried some demos. On the positive side:
1. It looks and behaves very polished. From playing around with the gallery the only issues i noticed is that the mouse wheel goes to the "outermost" control instead of the "innermost" and that there isn't a right click / context menu for text input fields with commands like copy, paste, etc (but the common shortcuts do work - including editing shortcuts like home, end, shift+movement, ctrl+d, etc).
2. According to btop the applications seem to use relatively little memory compared to other apps that look similar (~73MB). Of course it "helps" that other apps that look similar tend to use either Electron or some embedded web browser that balloons memory usage to several hundred MBs :-P.
3. There are practically no dependencies - even OpenGL seems to be an optional runtime dependence. Using objdump shows that it only depends on libm, libSM, libX11, libXext and -of course- libc. This is neat for self-contained applications.
4. The files are also relatively small - after stripping debug info from the release binaries (not sure why they're there) the hello world example is ~323KB, most examples (that use richer UIs) are somewhere between 350KB and 400KB and the gallery that contains everything is 1.4MB.
5. The UIs feel very light and snappy/responsive.
On the negative side:
1. The apps always seem to use ~4-5% CPU here - this is because they keep drawing the window all the time. Mangohud shows them not capping the FPS at all - which is good for smooth and responsive input, but drawing should stop if there are no changes to the scene/UI that need updates.
2. The code looks very messy - i do not see any `.clang-format` or anything like that. If you're going to use LLMs for writing the code IMO you should have both automatic code formatting and a `CODE_STYLE.md` (or something like that) for specifying how the code should look. It doesn't avoid the LLMisms in code but helps a lot to keep it readable (IMO at least).
3. There is no custom theme support (you can customize some aspects of its theme but you cannot make it look like, e.g, Windows 95, Mac OS X Leopard or Morrowind).
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.
I'm really curious how secure C software would be if reviewed by AI and run exclusively in a WASM runtime.
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.
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.
this is actually pretty neat, probably can replace lvgl or wayland-based GUIs, it's not mission critical, as long as it works I'm fine with vibe coding.
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.
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 can't 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."
That looks pretty readable to me. Somewhat noisier than SwiftUI due to all the repeated "cui_", but not much. I've seen far worse.
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.
edit: actually it's worse than reactive, it's full immediate-mode render-everything-every-frame.
Actually the reason is a very good one: most people design UIs graphically (Qt Designer, XCode Interface Builder, etc.), and UIs naturally lend themselves to the structure found in XML.
The use of C, in that case, was likely made for performance reasons and avoiding dependencies.
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.
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: https://www.nicbarker.com/clay
I used to look at the SW projects posted on HN, but not anymore. Everything is just AI slop now. Filtering the signal from the noise is way too much work for something that was supposed to be fun.
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.
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.
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.
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.
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.
Just take care when evaluating this for actual usage.
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.
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?
> there are glaring omissions that you'd see if you just played around with them for a minute.
That was more or less the point I was trying to make. You can vibe-code your own variant of this project (as the poster I was replying to suggested) but you run into the same problem that you need many more iterations of refinement. If we think that everyone is simply going to vibe-code their own UI frameworks (or whatever) going forward then I think that is a wrong assumption. The nature of software development hasn't changed, just the speed at which we can produce it.
This is just a comment in general, not specific to the project posted by OP.
This is a question that pops up all over the place these days. I can offer one answer.
System design is principally a process of identifying the best possible points at which to decouple the components that will make up the system. A clean design means that components can be swapped out for alternatives easily. Messy designs result in interlocking complexity.
Structuring your components as a general-purpose re-usable library forces you to consider how it is decoupled from consumers. If you do a good job designing it, it should be usable by all sorts of consumers, so you might as well make it a standalone library.
To a first approximation, I think this process of identifying clean decoupling points is the main thing that humans still need to babysit their agents over.
~200 USD in 1mo of claude, and 4 days of developer time -- call it 5000 USD
Very little. The motivation of contributing the open source is almost never a product, it is the feedback loop of work and achievement. Nobody will contribute to this kind of thing, because there is no feedback loop here.
It has no value, and you can tell basically immediately.
People are becoming extremely lazy and shipping the first slop the model generates because they get a rush from putting their stuff in tot he world as fast as possible.
However, I would bet significant money that all the projects like this (where every aspect has hallmark slopisms (the vibe interface design, the copy) will lose out to projects that are also heavily AI coded but that took the time and care to actually polish and differentiate themselves and thus are later to the game because they shipped after a few weeks or a month of work and refinement instead of a day.
AI can save you a lot of time but it can't save you from your own lack of restraint and your inability to discern and be an objective judge of the value your thing will have to other people. For software, mere existence is no longer sufficient anymore. Anyone can generate whatever you made instantly if you put zero effort or discernment into it. This is why so many of the Ainfluencers are emphasizing "taste".
But even taste won't save you on the end either, since anyone can clone your stuff as soon as it ships.
I personally think the future of software is probably just two extremes:
1. Personal dinky vibe coded apps that all have their individual creator as the sole user.
2. Large scale apps that don't work without significant marshaling of hard physical resources (e.g. LLMs themselves).
All the middle bits, user applications that target a specific problem space but that run locally and/or don't need legions of data centers and networks to run, will probably just die eventually. Maybe a couple of established apps will stick around in business contexts because employees all using their own personal apps and workflows causes too much coordination overhead, but at the consumer level I fully except everyone will be just vibing their own stuff pretty soon here.
I doubt it, as the principle of "garbage in, garbage out" still very much applies to LLMs. With or without AI, I'm not so naive to assume I'm going to quickly produce better software to solve well-established problems than others, with access to the same tools, who have put more time and effort into producing substantially similar software.
For specific and uncommon use cases? Sure. For something as generally applicable as a photo editor or a general purpose OS? Not a chance.
How does a five-day old C project have 611 stars? Hard to imagine that many people are writing user interfaces in C...
> but also vibecoded
This is something I'm seeing more often... vibecoded is starting to mean somebody just delegated their thinking to AI and whatever AI spit they just shipped blindly.
I think this is quite different then what I'd call AI-assisted coding, in which the engineer is still in the reins and you can see, even if you see the tales of a lot of code in short time, that the code has actually been looked over and polished by a human.
There might be a place for vibecoded software where only the outcome matter and the code is soft of disposable, but a library or a framework doesn't seem to be the place for that.
Yea, there's some nuance here. If you're a senior engineer in the pre-LLM world, you're likely spending more of your time guiding a team than you are writing lines of code. Perhaps you're writing prose for code review guidelines and guardrails around architectural patterns, with trust that this is followed and propagates to the org. Perhaps you're giving guidelines that anything that implies a business-level decision needs to be escalated and have a rollout plan, not just hardcoded.
The question is: if you're doing this same thing, but with LLMs as your "reports," is it vibe coding? The term was once an epithet, but I think it's expanded to refer to the technique of not living in an IDE, not the objective function.
If your objective function places an emphasis on maintainability: vibe coding can be a positive. If not: it can be a source of great pain. As with many things, it's the wielder, not the technique.
It looks like ShadCN-UI which AI likes to use.
> ... but also vibecoded by someone who just does frontend
This is the kind of thing I can't understand. They're trying to solve a problem they don't have. Assuming other people might need it, without understanding anything about that domain.
There's a thing that people who are infatuated with AI can't understand: anybody else has the same power as you! The old entrepreneurship-like ideal of trying to create something new just for the sake of innovation doesn't work anymore. Innovate on something that solves a problem you have, for you. Otherwise it's just slop, introducing chaos to system, increasing internet entropy.
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.
We have GPUI, we have web components, we have Clay UI. No one needs another C UI library.
> No one needs another C UI library.
Well, actually they do, but the LLM wouldn't know why. You gotta have used all these to figure it out, and then spend months wondering upon a better design, researching old experiments by random people in archived repos for inspiration. LLMs are useful only for that last part, quickly comprehending a strange repo you found from 15 years ago.
Some projects are worth it just for the rebrand.
i haven't checked out the code, but it looks a lot like LVGL (though a bit better)
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.
In the Apple world, Native usually means using the system UI components and the Apple guidelines.
> native means actual binary code running on the machine
Wouldn't "native ... for C" be redundant?
Only when mixing up languages with implementations, although C is mostly used as compiled language, there are interpreters as well.
Not the best title. It is not "for C", but in C. And currently useable on desktop + web but after looking at the project I think it will quickly be ported on mobile etc.
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.
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.
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.
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.
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)
It's not my project but I will definitely give the library a try.
Surprised post downvoting is not a thing yet.
You can flag it
for me, it strongly feels impolite to do so if the post is not breaking the rules
Yes, and flags are very powerful and I have seen them abused (IMO) a number of times as a replacement for a downvote button.
Yes, I sometimes wish for a downvote button, but so far I have more often wished for a way to silently make flagging a no op for users that abuse it.
For that HN posting rules should be updated with "no low-quality submissions".
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
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.
I think you’re kidding, but wouldn’t you have to maintain different code bases for each platform? C compiler gets you everywhere and WASM.
Yes, and? As the cost of code generation approaches zero, this starts to make more sense, especially if you do have mechanisms in place to ensure safety and correctness.
I did an experiment a couple weeks ago of having Opus 5.5 translate an MP3 decoder from Rust into Cortex-M33 assembly language, both raw asm and symbolasm. The code was 3x smaller and ~1.5x faster than Rust -O3. These seem like gains that are worth it.
As the cost of code gen approaches 0 the cost of the test suite actually grows. Not just in definition, but execution.
An MP3 decoder for a single target doesn't really run into that complexity, a UI components library for (Linux, Windows, macOS) * (x86-64, ARM64) suddenly has a 6x multiplier on what was already something with waaay deeper dependencies and integrations than MP3.
At least that's what I've noticed vibing my DE without external libraries. It went really fast when the complexity was small because most of the work was in adding code. Then it started taking longer to build and test, even with optimized builds and tests, than it took for the AI to do its part.
Yes that makes sense, but if you're iterating on software then I think C will generally win due to its ability to compile cross-platform until you want to build a "release" which you could do by having Fable translate it to ASM at that point.
Did you have it go directly to asm or emit the assembly from the Rust toolchain and then contract that? For small stuff, I have been having it write directly, or larger pieces I am having better results via contractions.
For this experiment I had it write directly.
I should add, part of the experiment was to test whether having variable names and (C style) types would help the LLM. For a task of this size (about 1.5 kLoC Rust, 3k insn asm) it was inconclusive, but for larger projects I suspect it would make a difference.
And the plan for symbolasm is to move past C style types into Rust style and maybe dependent typing, specifically to facilitate automated proofs.
at that point, how hard would it be to get the LLM to just make the binary? (iow, llm as compiler)
Once you have Wasm, it gets you everywhere and the best path to Wasm is Rust.
But Rust is unreadable compared to reasonably well written C. It matters if you care to read any of the code yourself and/or want to retain the ability to make manual changes. There is a reason C hasn't been displaced after all this time.
What an odd statement. Unreadable code is unreadable regardless of language. I’ve seen my fair share of unreadable C. Indeed Rust can be ugly in advanced use cases with heavy syntax but C’s simpler syntax does not mean it is always readable either. Hell, I've seen unreadable Python and Lua!
C has in fact been displaced in many places. Just because it survives in a few holdout contexts is a historical artifact more than a testament to the language.
Funny in a thread that started with `increasingly makes sense for compile times`
Fine, I'll make a fast rust compiler.
Rust with no deps and a single compilation unit is already fast.
Just ask the slop machine to translate the binary to every platform.
C has always made sense for building software as long as you do a memory safety pass.
The tools have gotten fancier, for sure, though.
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.
For larger codebases, things might be different.
https://fil-c.org/ exists
Leaving memory safety up to a model is wild. That's not a sound guarantee of safety for anything.
So, i downloaded it, built and tried some demos. On the positive side:
1. It looks and behaves very polished. From playing around with the gallery the only issues i noticed is that the mouse wheel goes to the "outermost" control instead of the "innermost" and that there isn't a right click / context menu for text input fields with commands like copy, paste, etc (but the common shortcuts do work - including editing shortcuts like home, end, shift+movement, ctrl+d, etc).
2. According to btop the applications seem to use relatively little memory compared to other apps that look similar (~73MB). Of course it "helps" that other apps that look similar tend to use either Electron or some embedded web browser that balloons memory usage to several hundred MBs :-P.
3. There are practically no dependencies - even OpenGL seems to be an optional runtime dependence. Using objdump shows that it only depends on libm, libSM, libX11, libXext and -of course- libc. This is neat for self-contained applications.
4. The files are also relatively small - after stripping debug info from the release binaries (not sure why they're there) the hello world example is ~323KB, most examples (that use richer UIs) are somewhere between 350KB and 400KB and the gallery that contains everything is 1.4MB.
5. The UIs feel very light and snappy/responsive.
On the negative side:
1. The apps always seem to use ~4-5% CPU here - this is because they keep drawing the window all the time. Mangohud shows them not capping the FPS at all - which is good for smooth and responsive input, but drawing should stop if there are no changes to the scene/UI that need updates.
2. The code looks very messy - i do not see any `.clang-format` or anything like that. If you're going to use LLMs for writing the code IMO you should have both automatic code formatting and a `CODE_STYLE.md` (or something like that) for specifying how the code should look. It doesn't avoid the LLMisms in code but helps a lot to keep it readable (IMO at least).
3. There is no custom theme support (you can customize some aspects of its theme but you cannot make it look like, e.g, Windows 95, Mac OS X Leopard or Morrowind).
On the "it depends on your taste" side:
1. It is clearly very web and mobile inspired.
2. It uses an immediate mode approach.
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.
I'm really curious how secure C software would be if reviewed by AI and run exclusively in a WASM runtime.
Looks like ShadCN. That too in C. It's really really elegant.
EDIT: It's immediate mode.
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.
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.
This is a major spillage of CUI
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.
Take the chips and rating as an example
https://yappologistic.github.io/CUI/#/c/chips-and-rating
It’s purely aesthetic as functionality (and ux) wise, chips are not different from checkbox with labels and rating is just a discrete slider.
And as I thought, you can see the duplicate code for switch and checkbox here.
https://github.com/yappologistic/CUI/blob/f1202e6d98cdc297f9...
People do need to differentiate between UX primitives and something that just looks different.
Also ids are generated with discrete values? Never seen something like that cui_make_id(ui, label) ^ 0xC0EC0001u
Can you please prompt your agent to generate a C++ binding?
Since AI has removed the bottleneck of writing code, so I understand why not go directly C. This could bite back sooner or later.
as elon musk said eventually the only language used would be assembly for systems programming because programming languages are only needed by humans.
That's a very easy thing to say when you own an AI company, and much harder to agree with when you pay by the token.
Bad acronym ; CUI is known as controlled unclassified information in the IC/DIB already.
this is actually pretty neat, probably can replace lvgl or wayland-based GUIs, it's not mission critical, as long as it works I'm fine with vibe coding.
Can't wait for RUI, the vibecoded Rust version of this vibecoded C project.
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.
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 can't 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."[1] https://fyne.io/
That looks pretty readable to me. Somewhat noisier than SwiftUI due to all the repeated "cui_", but not much. I've seen far worse.
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.
edit: actually it's worse than reactive, it's full immediate-mode render-everything-every-frame.
There's a reason QT uses XML for their layouting
You're on shaky ground using xml for ui layouts as posterchild for good developer ergonomics.
It’s like democracy: the worst except for all the others.
> There's a reason QT uses XML
Sure there is, it's just that the reason might be a very bad one unlike what you imply
Actually the reason is a very good one: most people design UIs graphically (Qt Designer, XCode Interface Builder, etc.), and UIs naturally lend themselves to the structure found in XML.
The tree structure is what matters, not XML. Qt itself moved to QML for new UIs: a dedicated language that’s nicer to write
I think you are missing the point entirely.
The use of C, in that case, was likely made for performance reasons and avoiding dependencies.
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.
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: https://www.nicbarker.com/clay
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.
That's on brand that nothing works, right? Text fields don't pop up your keyboard, date pickers don't react to attempts to pick dates,...
You know what this needs now? A Lua REPL.
Holy! Yes!
Done! ;)
https://github.com/seclorum/CUI.seclorum/tree/cui-lua-repl
I just touched a node in the node editor and it flung out of the viewport.
_sigh_
CUI - Controlled Unclassified Information.
Yeah I just did a double take at my desk reading this
Yeah. Not good acronym for this.
Any pre-built examples? Even if it's something like a calculator.
Looks great, but node editor is janky on mobile.
Design is essentially a clone of egui in C.
Wow I like this!
I wonder how this does with embedded devices. Would be cool to get an ESP32 with smooth animations/nice UI.
I used to look at the SW projects posted on HN, but not anymore. Everything is just AI slop now. Filtering the signal from the noise is way too much work for something that was supposed to be fun.
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.
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.
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 :)
Mentioning vibe coding and “It’s been a huge effort to add …” in the same phrase what a joke
life’s more fun if u do funny stuff
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.
Embedded guy here... Nah. No MMU, no problem. ;-)
Well, fewer problems!