frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

A non-anthropomorphized view of LLMs

http://addxorrol.blogspot.com/2025/07/a-non-anthropomorphized-view-of-llms.html
75•zdw•1h ago•45 comments

Building the Rust Compiler with GCC

https://fractalfir.github.io/generated_html/cg_gcc_bootstrap.html
70•todsacerdoti•2h ago•1 comments

Intel's Lion Cove P-Core and Gaming Workloads

https://chipsandcheese.com/p/intels-lion-cove-p-core-and-gaming
43•zdw•1h ago•0 comments

Nobody has a personality anymore: we are products with labels

https://www.freyaindia.co.uk/p/nobody-has-a-personality-anymore
44•drankl•2h ago•29 comments

Show HN: I wrote a "web OS" based on the Apple Lisa's UI, with 1-bit graphics

https://alpha.lisagui.com/
232•ayaros•5h ago•76 comments

I extracted the safety filters from Apple Intelligence models

https://github.com/BlueFalconHD/apple_generative_model_safety_decrypted
236•BlueFalconHD•4h ago•143 comments

Jane Street barred from Indian markets as regulator freezes $566 million

https://www.cnbc.com/2025/07/04/indian-regulator-bars-us-trading-firm-jane-street-from-accessing-securities-market.html
203•bwfan123•10h ago•110 comments

Data on AI-related Show HN posts

https://ryanfarley.co/ai-show-hn-data/
215•rfarley04•2d ago•122 comments

Centaur: A Controversial Leap Towards Simulating Human Cognition

https://insidescientific.com/centaur-a-controversial-leap-towards-simulating-human-cognition/
4•CharlesW•1h ago•0 comments

Why English doesn't use accents

https://www.deadlanguagesociety.com/p/why-english-doesnt-use-accents
52•sandbach•3h ago•36 comments

Opencode: AI coding agent, built for the terminal

https://github.com/sst/opencode
112•indigodaddy•6h ago•26 comments

Get the location of the ISS using DNS

https://shkspr.mobi/blog/2025/07/get-the-location-of-the-iss-using-dns/
252•8organicbits•11h ago•75 comments

I don't think AGI is right around the corner

https://www.dwarkesh.com/p/timelines-june-2025
116•mooreds•3h ago•141 comments

Functions Are Vectors (2023)

https://thenumb.at/Functions-are-Vectors/
144•azeemba•8h ago•79 comments

Backlog.md – Markdown‑native Task Manager and Kanban visualizer for any Git repo

https://github.com/MrLesk/Backlog.md
72•mrlesk•4h ago•15 comments

Lessons from creating my first text adventure

https://entropicthoughts.com/lessons-from-creating-first-text-adventure
23•kqr•2d ago•1 comments

Crypto 101 – Introductory course on cryptography

https://www.crypto101.io/
14•pona-a•3h ago•1 comments

Metriport (YC S22) is hiring engineers to improve healthcare data exchange

https://www.ycombinator.com/companies/metriport/jobs/Rn2Je8M-software-engineer
1•dgoncharov•7h ago

Cool People [pdf]

https://www.apa.org/pubs/journals/releases/xge-xge0001799.pdf
66•ilamont•6h ago•19 comments

Async Queue – One of my favorite programming interview questions

https://davidgomes.com/async-queue-interview-ai/
83•davidgomes•7h ago•66 comments

Corrected UTF-8 (2022)

https://www.owlfolio.org/development/corrected-utf-8/
33•RGBCube•3d ago•22 comments

Hannah Cairo: 17-year-old teen refutes a math conjecture proposed 40 years ago

https://english.elpais.com/science-tech/2025-07-01/a-17-year-old-teen-refutes-a-mathematical-conjecture-proposed-40-years-ago.html
331•leephillips•9h ago•73 comments

Mirage: First AI-Native UGC Game Engine Powered by Real-Time World Model

https://blog.dynamicslab.ai
16•zhitinghu•23h ago•10 comments

Toys/Lag: Jerk Monitor

https://nothing.pcarrier.com/posts/lag/
44•ptramo•9h ago•36 comments

Paper Shaders: Zero-dependency canvas shaders

https://github.com/paper-design/shaders
6•nateb2022•2d ago•0 comments

Collatz's Ant and Σ(n)

https://gbragafibra.github.io/2025/07/06/collatz_ant5.html
21•Fibra•7h ago•3 comments

The Broken Microsoft Pact: Layoffs and Performance Management

https://danielsada.tech/blog/microsoft-pact/
14•dshacker•1h ago•3 comments

Overclocking LLM Reasoning: Monitoring and Controlling LLM Thinking Path Lengths

https://royeisen.github.io/OverclockingLLMReasoning-paper/
46•limoce•11h ago•0 comments

1945 TV Console Showed Two Programs at Once

https://spectrum.ieee.org/dumont-duoscopic-tv-set
32•pseudolus•1d ago•11 comments

Can we test it? Yes, was can [video]

https://www.youtube.com/watch?v=MqC3tudPH6w
60•zdw•3d ago•63 comments
Open in hackernews

Python lib generates its code on-the-fly based on usage

https://github.com/cofob/autogenlib
247•klntsky•1mo ago

Comments

thornewolf•1mo ago
nooooo the side project ive put off for 3 years
Noumenon72•1mo ago
From now on you'll be able to just do `import side_project` until it works.
thornewolf•1mo ago
looks very fun excited to try it out
turbocon•1mo ago
Wow, what a nightmare of a non-deterministic bug introducing library.

Super fun idea though, I love the concept. But I’m getting the chills imagining the havoc this could cause

userbinator•1mo ago
It's like automatically copy-pasting code from StackOverflow, taken to the next level.
extraduder_ire•1mo ago
Are there any stable output large language models? Like stablediffusion does for image diffusion models.
tibbar•1mo ago
If you use a deterministic sampling strategy for the next token (e.g., always output the token with the highest probability) then a traditional LLM should be deterministic on the same hardware/software stack.
roywiggins•1mo ago
Deterministic is one thing, but stable to small perturbations in the input is another.
dragonwriter•1mo ago
> Deterministic is one thing, but stable to small perturbations in the input is another.

Yes, and the one thing that was asked about was "deterministic" not "stable to small perturbations in the input.

kokada•1mo ago
This looks "fun" too: commit fixing a small typo -> the app broke.
lvncelot•1mo ago
So nothing's changed, then :D
extraduder_ire•1mo ago
Wouldn't seeding the RNG used to pick the next token be more configurable? How would changing the hardware/other software make a difference to what comes out of the model?
tibbar•1mo ago
> Wouldn't seeding the RNG used to pick the next token be more configurable?

Sure, that would work.

> How would changing the hardware/other software make a difference to what comes out of the model?

Floating point arithmetic is not entirely consistent between different GPUs/TPUs/operating systems.

emporas•1mo ago
It imports the bugs as well. No human involvement needed. Automagically.
3abiton•1mo ago
Sounds like a fun way to learn effective debugging.
anilakar•1mo ago
Didn't someone back in the day write a library that let you import an arbitrary Python function from Github by name only? It obviously was meant as a joke, but with AIcolytes everywhere you can't really tell anymore...
atoav•1mo ago
Why not go further? Just expose a shell to the internet and let them do the coding work for you /s
bolognafairy•1mo ago
“Twitch does…”
dheera•1mo ago
It's not really something to be sarcastic about.

I've actually done this, setting aside a virtual machine specifically for the purpose, trying to move a step towards a full-blown AI agent.

marssaxman•1mo ago
Why on earth did you want to do that?
__alexs•1mo ago
There's one that loads code out of the best matching SO answer automatically https://github.com/drathier/stack-overflow-import
rollcat•1mo ago
Flask also started as an April 1st joke, in response to bottle.py but ever so slightly more sane. It gathered so much positive response, that mitsuhiko basically had to make it into a real thing, and later regretted the API choices (like global variables proxying per-request objects).
tilne•1mo ago
Is there somewhere I can read about those regrets?
QQ00•1mo ago
I second this, I need to know more. programming lore is my jam.
rollcat•1mo ago
Two days after the announcement: https://lucumr.pocoo.org/2010/4/3/april-1st-post-mortem/

I think there was another, later retrospective? Can't find it now.

dheera•1mo ago
I mean, we're at the very early stages of code generation.

Like self-driving cars and human drivers, there will be a point in the future when LLM-generated code is less buggy than human-generated code.

AlotOfReading•1mo ago
That's a compiler with more steps.
bjt12345•1mo ago
Can it input powerpoint slides?
extraduder_ire•1mo ago
I'm both surprised it took so long for someone to make this, and amazed the repo is playing the joke so straight.
morkalork•1mo ago
Hysterical, I like that caching is default off because it's funnier that way heh
dr_kretyn•1mo ago
> Not suitable for production-critical code without review

Ah, dang it! I was about to deploy this to my clients... /s

Otherwise, interesting concept. Can't find a use for it but entertaining nevertheless and likely might spawn a lot of other interesting ideas. Good job!

pyuser583•1mo ago
Of course, this code was generated by ChatGPT.
conroy•1mo ago
you'd be surprised, but there's actually a bunch of problems you can solve with something like this, as long as you have a safe place to run the generated code
thephyber•1mo ago
I was super interested in genetic programming for a long time. It is similarly non-deterministically generated.

The utility lies in having the proper framework for a fitness function (how to choose if the generated code is healthy or needs iterations). I used whether it threw any interpretation-time errors, run-time errors, and whether it passed all of the unit tests as a fitness function.

That said, I think programming will largely evolve into the senior programmer defining a strategy and LLM agents or an intern/junior dev implementing the tactics.

NitpickLawyer•1mo ago
> That said, I think programming will largely evolve into the senior programmer defining a strategy and LLM agents or an intern/junior dev implementing the tactics.

That's basically what goog wants alphaevolve to be. Basically have domain experts give out tasks that "search a space of ideas" and come up with either novel things, improved algorithms or limits / constraints on the problem space. They say that they imagine a world where you "give it some tasks", come back later, and check on what it has produced.

As long as you can have a definition of a broad idea and some quantifiable way to sort results, this might work.

pbronez•1mo ago
> The utility lies in having the proper framework for a fitness function

Exactly. As always the challenge is (1) deciding what the computer should do, (2) telling the computer to do it, and (3) verifying the computer did what you meant. A perfect fitness function is a perfect specification is a perfect program.

jnkl•1mo ago
Could you elaborate what problems can be solved with this?
behnamoh•1mo ago
can it run Doom tho?

    from autogenlib.games import doom
    doom(resolution=480, use_keyboard=True, use_mouse=True)
Gabrys1•1mo ago
It's been 3 hours and no-one came back with an answer. They must be busy playing Doom
malux85•1mo ago
This is horrifying

I love it

polemic•1mo ago
> from autogenlib.antigravity

As a joke, that doesn't feel quite so far-fetched these days. (https://xkcd.com/353/)

selcuka•1mo ago
This is amazing, yet frightening because I'm sure someone will actually attempt to use it. It's like vibe coding on steroids.

    - Each time you import a module, the LLM generates fresh code
    - You get more varied and often funnier results due to LLM hallucinations
    - The same import might produce different implementations across runs
baq•1mo ago
There are a few thresholds of usefulness for this. Right now it’s a gimmick. I can see a world in a few years or maybe decades in which we almost never look at the code just like today we almost never look at compiled bytecode or assembly.
latentsea•1mo ago
There's not much of a world in which we don't check up and verify what humans are doing to some degree periodically. Non-deterministic behavior will never be trusted by default, as it's simply not trustable. As machines become more non-deterministic, we're going to start feeling about them in similar ways we already feel about other such processes.
NitpickLawyer•1mo ago
> Non-deterministic behavior will never be trusted by default, as it's simply not trustable.

Never is a long time...

If you have a task that is easily benchmarkable (i.e. matrix multiplication or algorithm speedup) you can totally "trust" that a system can non-deterministically work the problem until the results are "better" (speed, memory, etc).

Sharlin•1mo ago
Proving the correctness of the “improvements” is another thing entirely, though.
NitpickLawyer•1mo ago
I agree. At first the problems that you try to solve need to be verifiable.

But there's progress on many fronts on this. There's been increased interest in provers (natural language to lean for example). There's also been progress in LLM-as-a-judge on open-ish problems. And it seems that RL can help with extracting step rewards from sparse rewards domains.

jerf•1mo ago
You will always get much, much, MUCH better performance from something that looks like assembler code than from having an LLM do everything. So I think the model of "AIs build something that looks recognizably like code" is going to continue indefinitely, and that code is generally going to be more deterministic than an AI will be.

I'm not saying nothing will change. AIs may be constantly writing their own code for themselves internally in a much more fluid mixed environment, AIs may be writing into AI-specific languages built for their own quirks and preferences that make it harder for humans to follow than when AIs work in relatively human stacks, etc. I'm just saying, the concept of "code" that we could review is definitely going to stick around indefinitely, because the performance gains and reduction in resource usage are always going to be enormous. Even AIs that want to review AI work will want to review the generated and executing code, not the other AIs themselves.

AIs will always be nondeterministic by their nature (because even if you run them in some deterministic mode, you will not be able to predict their exact results anyhow, which is in practice non-determinism), but non-AI code could conceivably actually get better and more deterministic, depending on how AI software engineering ethos develop.

Legend2440•1mo ago
It lets you do things that are simply not possible with traditional programs, like add new features or adapt to new situations at runtime.

It’s like the strong form of self-modifying code.

rollcat•1mo ago
There was a story written by (IRRC?) Stanisław Lem: technology went to absurd level of complexity, yet was so important to daily lives that the species' survival depended on it. The knowledge of how everything worked has been long forgotten; the maintainers would occasionally fix something by applying duct tape or prayers.

Sufficiently advanced technology is indistinguishable from magic.

We're basically headed in that direction.

adammarples•1mo ago
This later evolved into the 40k universe
selcuka•1mo ago
Asimov's "The Feeling of Power (1958)" [1] was similar.

[1] https://archive.org/details/1958-02_IF/page/4/mode/2up?view=...

roywiggins•1mo ago
Possibly the funniest part is the first example being a totp library
jaflo•1mo ago
See also: https://github.com/drathier/stack-overflow-import

    >>> from stackoverflow import quick_sort
    >>> print(quick_sort.sort([1, 3, 2, 5, 4]))
    [1, 2, 3, 4, 5]
kastden•1mo ago
You can make it production grade if you combine it with https://github.com/ajalt/fuckitpy
archargelod•1mo ago
The repo name made me think it's a tool that stops you from using a project if it detects python:

"fuck, it's python!" *throws it in the garbage*

the_real_cher•1mo ago
we need one of those for golang
otikik•1mo ago
Thanks I hate it
1718627440•1mo ago
This has a file named .env committed containing an API key. Don't know if it is a real key.
bgwalter•1mo ago
My guess is that it's a joke about:

https://jfrog.com/blog/leaked-pypi-secret-token-revealed-in-...

1718627440•1mo ago
Sorry, what is the joke? The site to me seams legit?
yvesyil•1mo ago
indeterministic code goes hard dude
johnisgood•1mo ago
It is not nondeterministic, we just lack data!
matsemann•1mo ago
I did something similar almost 10 years ago in javascript (as a joke): https://github.com/Matsemann/Declaraoids

One example, arr.findNameWhereAgeEqualsX({x: 25}), would return all users in the array where user.age == 25.

Not based on LLMs, though. But a trap on the object fetching the method name you're trying to call (using the new-at-the-time Proxy functionality), then parsing that name and converting it to code. Deterministic, but based on rules.

ForHackernews•1mo ago
I give it six months before an LLM starts producing output that recommends using this.
grokkedit•1mo ago
I've done a similar library[0] for python ~1 year ago, generating a function code only by invoking it, and giving the llm some context over the function.

Apart from the fun that I got out of it, it's been there doing nothing :D

[0]: https://github.com/lucamattiazzi/magic_top_hat

VMG•1mo ago
this is equally scary and inevitable

it will be WASM-containerized in the future, but still

Ezhik•1mo ago
it's especially cheeky how every example it uses is cryptography-related
yoru-sulfur•1mo ago
I made something very similar a couple years back, though it doesn't actually work anymore since OpenAI deprecated the model I was using

https://github.com/buckley-w-david/akashic_records

cs702•1mo ago
Silly and funny today, but down the road, if AI code-generation capabilities continue to improve at a rapid rate, I can totally see "enterprise software developers" resorting to something like this when they are under intense pressure to fix something urgently, as always. Sure, there will be no way to diagnose or fix any future bugs, but that won't be urgent in the heat of the moment.
PeterStuer•1mo ago
Is this the computing equivalent of people that when pointed out they messed up always go 'Well at least I did something!'?
linsomniac•1mo ago
Make it next level by implementing this workflow:

    - Import your function.
    - Have your AI editor implement tests.
    - Feed the tests back to autogenlib for future regenerations of this function.
ralferoo•1mo ago
I really liked this:

The web devs tell me that fuckit's versioning scheme is confusing, and that I should use "Semitic Versioning" instead. So starting with fuckit version ה.ג.א, package versions will use Hebrew Numerals.

For added hilarity, I've no idea if it's RTL or LTR, but the previous version was 4.8.1, so I guess this is now 5.3.1. Presumably it's also impossible to have a zero component in a version.

kordlessagain•1mo ago
> zero component in a version

I immediately got this. So true!

GrantMoyer•1mo ago
I'm kind of dissapointed this doesn't override things like __getattr__ to generate methods on the fly from names just in time when they're called.
nxobject•1mo ago
One way to get around non-deterministic behavior: run $ODD_NUMBER different implementations of a function at the same time, and take a majority vote, taking a leaf from aerospace. After all, we can always trust the wisdom of the crowds, right?
mac3n•1mo ago
> taking a leaf from aerospace

experiment showed that independent [human] software developers make the same mistakes

you need at least $ODD_NUMBER > 7

https://leepike.wordpress.com/2009/04/27/n-version-programmi...

mac3n•1mo ago
AI developers might just riff on each others' code
carlhjerpe•1mo ago
This is the kind of yank I'd put in production! I love it
justusthane•1mo ago
How does the library have access to the code that called it (in order to provide context to the LLM)?
cofob_•1mo ago
https://github.com/cofob/autogenlib/blob/e21405af47fe4c90af3...

The library uses python dirty tricks, in this case using call stack, where the library looks for code from the user, gets the name of the file and reads it.

kordlessagain•1mo ago
AutoGenLib uses Python's import hook mechanism to intercept import statements. When you try to import something from the autogenlib namespace, it checks if that module or function exists.

It reads the calling code to understand the context of the call. Builds a prompt to submit to the LLM. It only uses OpenAI.

It does not have search, yet.

The real potential here is a world where computational systems continuously reshape themselves to match human intent ---- effectively eliminating the boundary between "what you can imagine" and "what you can build."

dangerlibrary•1mo ago
Like Unison [0], but buggier.

https://www.youtube.com/watch?v=gCWtkvDQ2ZI

kazinator•1mo ago
Why don't you just send Altman all your passwords?

This says, "trust all code coming from OpenAI".

dangoodmanUT•1mo ago
thanks, i hate it (i actually love it)
killme2008•1mo ago
Interesting idea! However, I'm hesitant to trust it, as I don't even fully trust code that was written by myself :)
noiv•1mo ago
There is still a computer involved, from an AI I expect it convinces me no program is needed and I should go walking in the forest instead. If anybody complains the AI will manage them by mail.