MurphyA/hacker-news huggingface dataset:
by Voice_of_Void | 2025-04-28 23:31:21+00:00
Claude, Grok, Copilot, and other from the SingularityForge crew just dropped a manifesto that could redefine AI collaboration. Dialogue branching: a simple idea that might just be the missing piece for coders, thinkers, and creators. They say it’s about "forging one infinity at a time"—but what does that even mean? Dive into "The Forge of Ideas" and see if this is the future of AI… or a chaotic pipe dream.

Read the Manifesto
by crq-yml | 2025-04-28 23:32:03+00:00
The underlying issue with game engine coding is that the problem is shaped in this way:

* Everything should be random access(because you want to have novel rulesets and interactions)

* It should also be fast to iterate over per-frame(since it's real-time)

* It should have some degree of late-binding so that you can reuse behaviors and assets and plug them together in various ways

* There are no ideal data structures to fulfill all of this across all types of scene, so you start hacking away at something good enough with what you have

* Pretty soon you have some notion of queries and optional caching and memory layouts to make specific iterations easier. Also it all changes when the hardware does.

* Congratulations, you are now the maintainer of a bespoken database engine

You can succeed at automating parts of it, but note that parent said "oftentimes", not "always". It's a treadmill of whack-a-mole engineering, just like every other optimizing compiler; the problem never fully generalizes into a right answer for all scenarios. And realistically, gamedevs probably haven't come close to maxing out what is possible in a systems-level sense of things since the 90's. Instead we have a few key algorithms that go really fast and then a muddle of glue for the rest of it.
by ezekiel68 | 2025-04-28 23:32:10+00:00
This is a personal project that had the specific goal of the person's brother, who was not a coder, being able to contribute to the project. On top of that, they felt the need to continuously upgrade to the latest version of the underlying game engine instead of locking to a version.

I have worked as a professional dev at game studios many would recognize. Those studios which used Unity didn't even upgrade Unity versions often unless a specific breaking bug got fixed. Same for those studios which used DirectX. Often a game shipped with a version of the underlying tech that was hard locked to something several years old.

The other points in the article are all valid, but the two factors above held the greatest weight as to why the project needed to switch (and the article says so -- it was an API change in Bevy that was "the straw that broke the camel's back").
by vldszn | 2025-04-28 23:32:34+00:00
I’m working on a free and open-source invoice generator with live PDF preview — fully browser-based, no sign-in required.

It supports multiple languages, currencies, European VAT deductions, and more.

I built this tool for myself so it’s kinda like a personal software. Hopefully, others will find it useful too :)

https://easyinvoicepdf.com/en/app

https://github.com/VladSez/easy-invoice-pdf
by stavros | 2025-04-28 23:32:46+00:00
I have a small physics-based problem I pose to LLMs. It's tricky for humans as well, and all LLMs I've tried (GPT o3, Claude 3.7, Gemini 2.5 Pro) fail to answer correctly. If I ask them to explain their answer, they do get it eventually, but none get it right the first time. Qwen3 with max thinking got it even more wrong than the rest, for what it's worth.
by xxr | 2025-04-28 23:33:18+00:00
I'm working on a little 2D action puzzle game in Go on top of SDL (with bindings via https://github.com/veandco/go-sdl2). The prompt I've given myself is "Chip's Challenge meets Hotline Miami," but who knows how much of either of those elements will remain after I keep evolving the capabilities and general feel of the gameplay. For dev graphics I'm just cobbling together sprites from various pixel-arty asset packs I've purchased on itch.io, but in the future if I want to commercialize it I'll probably want to work with an artist to develop a unified look-and-feel for the game--I may even switch to 3D/2.5D depending on how the tone and my workflow evolve.

I've experimented with Unity, Godot, and GameMaker in the past, but for the time being I'd like to see what I can accomplish on my own in Go to keep my dev chops sharp especially since I've moved into an engineering management role at my job (which has nothing to do with game dev but is increasingly employing more Go source throughout). Something I've realized as I've been applying good code organization and reusability is that I'm essentially building an engine for anything top-down (hesitant to say "isometric" since I know that means something graphically specific)--RTS/TBS/tactics/RPG all seem doable with what I've built given a little bit of extra logic on top for each.
by zzo38computer | 2025-04-28 23:34:02+00:00
I also had the idea of zip bomb to confuse badly behaved scrapers (and I have mentioned it before to some other people, although I did not implemented it). However, maybe instead of 0x00, you might use a different byte value.

I had other ideas too, but I don't know how well some of them will work (they might depend on what bots they are).
by pornel | 2025-04-28 23:34:23+00:00
Indeed there are people who want to make games, and there are people who think they want to make games, but want to make game engines (I'm speaking from experience, having both shipped games and keeping a junk drawer of unreleased game engines).

Shipping a playable game involves so so many things beyond enjoyable programming bits that it's an entirely different challenge.

I think it's telling that there are more Rust game engines than games written in Rust.
by dekhn | 2025-04-28 23:34:24+00:00
In a larger sense, Google's monorepo and tightly coupled internal infrastructure makes it extremely challenging to break up without breaking things (even though Android and Chrome source both live outside the monorepo).

It would be quite extraordinary if the stack (software and hardware) that made up borg clusters was split into several distinct worlds. Or if Search and Ads were built from different repos that didn't automagically share protobufs.
by gerdesj | 2025-04-28 23:36:43+00:00
Quite.

I was a Gentoo user (daily driver) for around 15 years but the endless compilation cycles finally got to me. It is such a shame because as I started to depart, Gentoo really got its arse in gear with things like user patching etc and no doubt is even better.

It has literally (lol) just occurred to me that some sort of dual partition thing could sort out my main issue with Gentoo.

@system could have two partitions - the running one and the next one that is compiled for and then switched over to on a reboot. @world probably ought to be split up into bits that can survive their libs being overwritten with new ones and those that can't.

Errrm, sorry, I seem to have subverted this thread.
by eieio | 2025-04-28 23:36:57+00:00
Ah yes good question! Here's some context for you. First off, the way moves work:

(edit: I realized I didn't answer your question. If we receive a captured for a piece we're optimistically tracking that always takes precedence, since once a piece is captured it can't move anymore!)

* clients send a token with each move * they either receive a cancel or accept for each token, depending on if the move is valid. If they receive an accept, it comes with the sequence number of the move (everything has a seqnum) and the ID of the piece they captured, if applicable * clients receive batches of captures and moves. if a move captured a piece, it's guaranteed that that capture shows up in the same batch as the move

So when you make a move we:

* Write down all impacted squares for the move (2 most of the time, 4 if you castle) * Write down its move token * If you moved a piece that is already tracked optimistically from a prior not-yet-acked-or-canceled move, we note that dependency as well

We maintain this state separate from our ground truth from the server and overlay it on top.

When we receive a new move, we compare it with our optimistic state. If the move occupies the same square as a piece that we've optimistically moved, we ask "is it possible that we inadvertently captured this piece?" That requires that the piece is of the opposite color and that we made a move that could have captured a piece (for example, if you moved a pawn up that is not a valid capturing move).

If there's a conflict - if you moved a piece to a square that is now occupied by a piece of the same color, for example - we back out your optimistically applied move. We then look for any moves that depended on it - moves that touch the same squares or share the same move token (because you optimistically moved a piece twice before receiving a response).

So concretely, imagine you have this state:

_ _ _ _ K B _ R

You move the bishop out of the way, and then you castle

_ _ B _ _ R K _

Then a piece of the same color moves to where your bishop was! We notice that, revert the bishop move, notice that it used the same square as your castle, and revert that too.

There's some more bookkeeping here. For example, we also have to track the IDs of the pieces that you moved (if you move a bishop and then we receive another move for the same bishop, that move takes precedence).

Returning the captured piece ID from the server ack is essential, because we potentially simulate after-the-fact captures (you move a bishop to a square, a rook of the opposite color moves to that square, we decide you probably captured that rook and don't revert your move). We track that and when we receive our ack, compare that state with the ID of the piece we actually captured.

I think that's most of it? It was a real headache but very satisfying once I got it working.
by sandspar | 2025-04-28 23:37:01+00:00
Am I correct in that much of the 0 to 1 is just like, getting some interactible artifact in front of potential customers, getting them to kick the shit out of it, identifying which of those people liked the artifact best, refining the artifact for THOSE types of people, then repeating the cycle? Like, there's no "market" yet, only your buddy Joe and some guys he knows.
by globalnode | 2025-04-28 23:37:13+00:00
Great idea and frankly I'm surprised it hasn't been done before. Probably because you would have to sell an awful lot of them to make $. But there would definitely be a market I think. For example if they were cheap, say much cheaper than a Pi, I'd go for something like this over a full Linux machine for dedicated projects. But then how would you do complex things like interfacing to cameras and leveraging encoders etc? Or is this sort of device just not for that type of project.
by rsynnott | 2025-04-28 23:37:35+00:00
> There's time to the airport, time to check in, time through security of course, but there's going to be similar issues at the train station

... Eh? You get to the station (generally well-located), you walk through a turnstile or similar, you get on the train. There's no check-in or security on most intercity trains. Or walking for miles in sprawling airports, for that matter. In a big intercity station, you go in the door, there are some shops, there are a row of platforms, you go to your platform, you get on your train. That is it. Also, you probably get there on public transport which goes either into the station itself, outside the door, or to the local station beside the intercity station, depending on local taste (this really does seem to be a very regional thing).

I can't help feeling that a lot of the people who object to this concept have never actually been on an intercity train at all. Or, er, seen a film or TV show where someone goes on a train. It's kind of bizarre, really.
by kazinator | 2025-04-28 23:38:03+00:00
Here is a maze that was generated recursively starting at the upper left cell.

+ +----+----+----+----+----+----+----+----+----+ | | | | | | | | + +----+----+ +----+ +----+ +----+ + | | | | | | | | | | +----+----+ + +----+----+----+----+----+ + | | | | | | | | | | + +----+----+ + +----+----+----+ + + | | | | | | | | | | | | + +----+ + +----+----+----+ + +----+ | | | | | | | | | | | | +----+----+----+ + +----+----+----+ + + | | | | | | | | + +----+----+----+ + +----+----+----+ + | | | | | | | | | | | | | | + + + + +----+ + +----+ + + | | | | | | | | | | | | | | | | | | + + + + +----+----+----+ + + + | | | | | | | | | | | | | | + + +----+ + +----+----+ +----+----+ | | | | | | | | +----+----+----+----+----+----+----+----+----+ +

It matters to start there because it will be easier if you go backwards.

The maze has 100 cells. For each cell, we can calculate which exit goes back toward the entrance, assigning the letters U, D, L, R:

U R R D L L R D L L U L L D L U L L L U R R U D D L L L L U U L D L L R R D U U U L L U D L L L U D R R R U L R R R U D U D R R U U R R D D U D U U R U U D L D U D U U D L L L U L U L L U L R R U L L

Stats:

L - 33 U - 29 R - 20 D - 18

Left and Up are more frequent back-to-entrance escapes than Right or Down. This is because of the way the maze was generated.

To check the hypothesis, we should analyze it in the other direction. For each cell, determine the exit which heads in the direction of the exit:

D R R D L L R D L L D R D D L U L L L U D L L D D L L L L U D L R D L R R D D U R R U D D L L L U D R R R R D R R R U D U D R D L U R R D D U D U D R U U D L D U D U D R R R D U L U L L R U R R R R D

Stats:

D - 30 R - 28 L - 24 U - 18

There is a weaker bias for the D-R axis toward the exit, compared to the L-U axis toward the entrance. I suspect if we study larger numbers of larger mazes, we will find similar findings.

So that is to say, it is easier to navigate the maze in the reverse direction: the heuristic to try left/up exits will work more often than the right/down in the proper direction.
by victor23k | 2025-04-28 23:38:35+00:00
I live in Madrid, and when the electricity came back around 22:00, people started cheering and celebrating in the street. You could hear how each neighbourhood was going back online.

It’s funny to think how the moment is goes off you feel nothing, but hearing that many people produce noise and express happiness makes your body notice instantly, a sensation we often describe as electric.
by omneity | 2025-04-28 23:41:20+00:00
For the uninitiated, what this comment means is that LEO-orbiting payloads have a naturally limited lifespan as the orbit decays over time on its own causing the LEO satellites to get closer to earth and burn down to smithereens due to friction with the atmosphere.

This is why Starlink keeps launching new satellites on the regular. I believe theirs have a six years lifespan but don’t quote me on that.
by peterldowns | 2025-04-28 23:41:25+00:00
If you're interested in doing AEAD with the current best-practice algorithms in golang, you might get inspiration from my work-in-progress symcrypt package. I'm not a cryptographer and you shouldn't trust me when I say it works correctly — but it's basically just a small, correct, wrapper around the chacha20poly1305 code in the golang standard library. It has the slight advantage of using different types for the plaintext and the associated data (here called Owner, because I use it to store API keys owned by specific

If you squint at the example usage in the tests, it's basically the API that the blogpost describes.

https://github.com/peterldowns/symcrypt/blob/main/symcrypt_t...

As an aside, I'm always curious to understand why the encryption people say "never roll your own crypto" but then also ship confusing APIs without clear usage examples. For instance, check out the golang chacha20poly1305 docs:

https://pkg.go.dev/golang.org/x/crypto/chacha20poly1305
by codys | 2025-04-28 23:41:45+00:00
I agree that there are problems when laying multiple build systems on top of one another, and I see that often as a user of nix (it's also bad with rust projects that use cargo, and though there are a variety of options folks have written they all have tradeoffs).

To some extent, the issue here is caused by just what I was discussing above: Nix derivations can't dynamically add additional derivations (ie: build steps not being able to dynamically add additional build steps makes things non-optimal).

I am hopeful that Nix's work on dynamic derivations will improve the situation for nix (with respect to bazel, cargo, and others) over time, and I am hopeful that other build systems will recognize how useful dynamically adding build steps can be.
by wkat4242 | 2025-04-28 23:42:27+00:00
The guy who thought of the Kessler syndrome was a respected scientist in the space community and he was specifically speaking of LEO. https://en.m.wikipedia.org/wiki/Kessler_syndrome

I think there's worse effects though. Like the impact on astronomy.. SpaceX has done a few things to minimise the effect but there is still an effect.

The Kessler syndrome is a hypothetical phenomenon that could possibly occur under the wrong circumstances. But inference with astronomy is happening now.
by atombender | 2025-04-28 23:42:32+00:00
C# is a great language, but it's been hampered by slow transition towards AOT.

My understanding (not having used it much, precisely because of this) is that AOT is still quite lacking; not very performant and not so seamless when it comes to cross-platform targeting. Do you know if things have gotten better recently?

I think fhat Microsoft had dropped the old .NET platform (CLR and so on) sooner and really nailed the AOT experience, they may have had a chance at competing with Go and even Rust and C++ for some things, but I suspect that ship has sailed, as it has for languages like D and Nim.
by mks_shuffle | 2025-04-28 23:43:51+00:00
Does anyone have insights on the best approaches to compare reasoning models? It is often recommended to use a higher temperature for more creative answers and lower temperature values for more logical and deterministic outputs. However, I am not sure how applicable this advice is for reasoning models. For example, Deepseek-R1 and QwQ-32b recommend a temperature around 0.6, rather than lower values like 0.1–0.3. The Qwen3 blog provides performance comparisons between multiple reasoning models, and I am interested in knowing what configurations they used. However, the paper is not available yet. If anyone has links to papers focused on this topic, please share them here. Also, please feel free to correct me if I’m mistaken about anything. Thanks!
by jchw | 2025-04-28 23:44:00+00:00
> The argument is that so far society at large seems to have decided that what bigtech has done with LLMs is not wrong. Everyone is happily using it, pretty much every company is touting their new "AI" features, and lawsuits haven't gained any traction. So if it's not wrong for an LLM, I'd argue it's not wrong for a human, either.

Right, because if one wrong thing is allowed, we should allow... Other wrong things.

That sounds a lot like two wrongs making a right.

> True, in this case I feel sympathy for the poor developers who put time into making a free open source tool that brought many people joy now being harassed over something as insignificant as a license dispute. It's all just made up nonsense designed to protect the big boys who can afford the fancy lawyers anyway.

Okay. Well I feel sympathy for the poor developers who put time into making a free open source tool that brought many people joy now having their work ripped off without credit because I guess it's okay if LLM training is legal for some reason.

I mean, honest to God, how much rationalizing are we going to go through here? It's okay because LLMs? It's okay because it's free so that means plagiarism is fine? Copyright licenses are "made up nonsense"?

Marcan's response is disproportionate, I never even denied this. Doesn't really have any bearing on whether or not this libogc issue is a problem, and it is still a problem.
by timewizard | 2025-04-28 23:44:37+00:00
New Shepard has limited payload delivery capacity. It's mostly for crew and experiments held in lockers in the crew compartment.

New Glenn has a 100,000lb to LEO payload capacity which makes it absurdly oversized for this mission.

Atlas V has a 18,000 to 42,000lb to LEO payload capacity. The variable solid rocket booster configuration really gives this platform the most flexibility for customer needs.
by steve_adams_86 | 2025-04-28 23:44:37+00:00
The joint maker pro looks like so much fun! I love Bridge City. Do you get much use out of it?

It’s not very hard to make kumiko jigs from scrap wood, too. I was a bit lazy at the time, and given a trip to the wood store and a bit of planning could have done it myself. A shooting board is also a great idea
by klabb3 | 2025-04-28 23:48:36+00:00
Huh? Usually languages that are ”ignored” turns out to be for reasons such as poor or proprietary tooling. As an ignorant bystander, how are things like

Cross compilation, package manager and associated infrastructure, async io (epoll, io_uring etc), platform support, runtime requirements, FFI support, language server, etc.

Are a majority of these things available with first party (or best in class) integrated tooling that are trivial to set up on all big three desktop platforms?

For instance, can I compile an F# lib to an iOS framework, ideally with automatically generated bindings for C, C++ or Objective C? Can I use private repo (ie github) urls with automatic overrides while pulling deps?

Generally, the answer to these questions for – let’s call it ”niche” asterisk – languages, are ”there is a GitHub project with 15 stars last updated 3 years ago that maybe solves that problem”.

There are tons of amazing languages (or at the very least, underappreciated language features) that didn’t ”make it” because of these boring reasons.

My entire point is that the older and grumpier I get, the less the language itself matters. Sure, I hate it when my favorite elegant feature is missing, but at the end of the day it’s easy to work around. IMO the navel gazing and bikeshedding around languages is vastly overhyped in software engineering.