HN user
Current benchmarks have ceilings, usually 100%. This benchmark aims to be a long lasting, high correlation with the ability to solve real world problems and follow complex instructions, and unbounded (meaning it can always go higher).
Awesome! Let me know if it works for your propose. If not, raise a issue on github and lets work together.
His claims are indeed correct; Yes, you got my point tks!; AND the loop produced architecture gains that are not exclusive to the GoWin FPGA (CoreMark/Mhz is higher than VexRiscV)
Tks! Did you apply it to hardware design or to another field?
Whats your take on it? "If I read it, what point should I pay attention to?", I guess is what I'm trying to say
"Not at all, completely novel idea. What made you thought of such thing?" hahaha
Yeah, you are totally right. Its a work in progress, and the post was written by an LLM - Im trying to improve on it (dash pun intended).
Regarding the benchmark overfitting, absolutely, it's pretty much overfitted. This CPU will only be as good as it benchmark. If I have the time I will try to get some applications and optimize for those.
I genuinely laughed reading the first words. Yeah, its hard to be novel
For sure! The hypothesis generation gotta be improved. Your take on the "least likely" is interesting. In the beginning of the repo I was having problems with "hypothesis convergence", your idea may be a nice way to introduce the much needed variability
Is slop verifiable? If so we can throw it in the loop... The point is that this loop can be pointed at any verifiable work. Yeah you are seeing it raw, the verifier is the principle you talked about. Yes it was fully AI generated, It will be refined
Nice references! tks
Absolutely, today it's FPGAs.. Tomorrow can be whole companies
"I would LOVE somebody to bounce AI off of reversing the architecture and bitstreams for the stupid-ass closed-source FPGAs."
The only reason I'm using Gowin is because it has a slightly more mature opensource tooling. Maybe we can apply this loop to nextpnr also
The frontier is the verifier not in the sense of this project, but to every project. If we have a good verifier for a task, any task, this type of loop can be applied to it. Today LLMs are good enough to tackle FPGA projects, but what this type of loop will be applicable to many more things
Board should be arriving next week. I will let you know!
Ive been receiving rate limits even with full quotas... I guess compute isn't growing as fast as demand
I like the way its looking. Maybe because of the familiarity with the Jupyter Notebook
Recently I've been noticing that claude "stalls" on a prompt and take minutes to finish, with no apparent work being done. Maybe they are rate limiting, even when you are well under the quotas.
The moment that not releasing a model becomes more financially beneficial than releasing it, that's when AI becomes truly dangerous. Between doomerism and marketing, the release or rather lack of, Claude Mythos is the first model that really spooked me. Not because of its capabilities, but because of the gatekeeping. Yes, Anthropic is playing the good guys here, but what if they aren't? What if they gatekeep the next model to Mythos for their own benefit? They would pull so far ahead of society and other software companies, would acquire so much power (through hacking) and money (through arbitrage and trading strategies in the financial markets), that the next model might be the final frontier. The AI 2027 vision doesn't look so distant after all.
Apple recently released https://github.com/apple/container, a CLI tool for running Linux containers natively on macOS with Apple Silicon. It's fast and lightweight, but it's terminal-only.
I built Container GUI — a native SwiftUI app that wraps the CLI and gives you a proper desktop interface for managing containers, images, volumes, networks, and more.
Features: - Containers: list, inspect, start/stop/kill/delete, live log streaming - Images: browse, inspect (config, platform, history), pull with streaming progress - Volumes & Networks: full CRUD - Builder & System: status, start/stop services, disk usage
Tech: Pure SwiftUI + AppKit (for the log viewer), MVVM with @Observable, Swift 6 strict concurrency, zero dependencies. Wraps the CLI via Foundation.Process.
Would love feedback!
Its based on the latest political and economic events. I think it may be better than many recent sets.
We are building lovable for enterprise software, and we are genuinely impressed with what it can do in a single prompt. Authentication and persistence comes out of the box.
This was mostly vibe coded with grok and o3 in two hours.
The main advantage of using a new and constant token for reasoning is that, while we would pay the full price during training, in the inference phase, we could do most, if not all, the "reasoning" in one shot, without having to feed one generation token at a time.
Reasoning 1 vs. 3 is the number of reasoning tokens between each "text" token. The 1 reasoning token is exactly what you see in the picture explanation in the article.
The generalization comes from making the network predict a <"start reasoning token"> and end the sequence only when it predicts a <"end reasoning token">. The training dataset for the upcoming experiment contains examples like: """ Q: What is 3+2? A: 3 + 2 is equal to <start reasoning> <reasoning> ... <reasoning> <end reasoning> 5 """