MicronewsHacker News and the AI labs on X | Items | 60 | |
|---|---|---|---|
| Updated | |||
vinibrasil.com
unsung.aresluna.org
nolanlawson.com
outerzone.co.uk
jetstream.security
otape.org
mprnews.org
arxiv.org
bbrouter.com
Hi HN, I kept wiring Ben Eater's 8-bit computer wrong, so I built a realistic virtual breadboard editor. Some of the nice features are side-by-side diff, scope, schematics auto-sync, auto-router (BBRouter stands for breadboard router), and my favorites: upload from the real Arduino IDE and connect to your AI with MCP, let Claude & co build it or help you troubleshoot. The link is the SAP-1 running. You can orbit it, probe a hole with the scope, slow the clock down, play with the virtual displays for debugging, then you can actually build it following the step-by-step instructions. A side-goal is to create a community, there are quite a lot of simulators out there but mostly offline / too abstract to realistically use it for a real build. I also never found one that had a decent UI/UX and worked well on mobile or with a trackpad. Happy to answer anything, and tell me what breaks. p.s. Maker plan is $7/month; code HACKERNEWS makes the first month free and then $5/month for as long as you keep it.
emarzion.github.io
spectrum.ieee.org
uvdn7.github.io
github.com
smithsonianmag.com
blog.keyvan.net
help.openai.com
mashable.com
pgdp.net
learnfromx.com
sourceforge.net
simonwillison.net
youtube.com
newyorker.com
karpathy.bearblog.dev
YouTube-style UI over 6,454 videos sourced from 39,834 HN comments since 2007.
twitter.com
epoyraz.github.io
Based on vermiceli's annotated disassembly of Contra: . Thanks for the great work. I ported it in two steps. First to C: the game logic is translated routine by routine from the 6502 assembly, and checked frame by frame against the original in the Mesen emulator. Then the C code to WebAssembly so it runs in the browser. The cherry on top: online multiplayer, so two players can play co-op over the internet. Source:
atlasum.net
fullycharged.show
daemonology.net
ryanmadden.net
pgedge.com
pivotlake.io
datavorous.com
thedrive.com
dl.acm.org
news.yale.edu
theguardian.com
cairoreport.org
theregister.com
pluralistic.net
jointter.com
Hello everyone. I’m a mathematician by training, and I love mathematical and logical puzzles and brain-teasers. Inspired by popular games like Sudoku and Wordle, I decided to come up with an engaging game of my own. As it turns out, that’s not so easy! I had a few ideas, but beyond the core mechanics, a game also needs to be interesting and easy to explain — after all, nobody (including me) wants to spend a long time reading through rules. Let’s start with the concept, which came to me quite spontaneously: what if we represented letters like the digits on a digital clock — using lines, with dots at the points where those lines intersect? For instance, the letter "E" would consist of four lines and six dots — three at the intersections and three at the ends of the lines. It turns out that every letter of the Latin alphabet can be represented this way (with a minor caveat) using three rows of dots connected by some lines. This immediately presented a challenge: how do you represent O-shaped parts, like those found in "B", "O", or "R"? I decided not to use O-shapes, an use onl rectangles/squares. This "alphabet" is always displayed below the game board, so the player can see the letters. The goal of the game is simple: you are presented with three rows of dots and a set of lines, and you have to figure out the word. A great feature of the game is that it’s possible to deduce the word in a single turn — all the necessary information is right there on the board, allowing you to arrive at the answer with certainty. And what if you can’t figure it out on the first try? You can enter a guess, much like in Wordle: if the lines from the entered word are part of the target word, they turn green; if not, they turn red. The same applies to the dots. As you play, more and more lines gradually appear... Why provide some lines at the start? To uniquely identify a specific word — or a small set of words — from the dictionary. For example, you could select a configuration of lines that corresponds to only one word, like "RADIO", or perhaps to just two possible words, such as "WEIGH" and "WRONG". The rules seem clear, but the mechanics — not so much. There are dots on the board; when I enter a word, I realize there aren't enough dots. What should I do? Initially, if the target word had 5 letters, I allowed users to enter 4- or 5-letter guesses, but that just confused players. So, I came up with a different solution: adding red dots for dots that aren't part of the target word. Another drawback is that the game is somewhat skewed. Since letters are processed from left to right, the first letters are revealed more frequently than the last ones. Then there’s the game design itself: should the target words be 5 letters long, or 6? Should a single board allow for multiple possible answers (like "WEIGH" and "WRONG"), or should it be limited to one — or perhaps more than two? Should the difficulty increase from Monday to Sunday? Currently, it’s set up this way: Monday is the easiest (a few 3-letter words), while Sunday is the hardest (more than two 7-letter words). The tech stack is simple: I use Flask for the backend and Python for the algorithms; I wrote the algorithms myself. While the JS, HTML, and CSS were created with the help of AI. I’d love for you to test the game and share what you like, what you don’t, and what could be improved. Specifically, I’d like to know: 1. Is the game and its goal clear? 2. Is it fun to play, and what could be improved? 3. Would you share it with your friends? I welcome any constructive criticism. You can find the game at It’s free and requires no registration. Thank you very much.
phoronix.com
a-side.social
science.nasa.gov
casio.com
twitter.com
github.com
x.com
torrentfreak.com
blog.talosintelligence.com
n.aspencreekbs.com
demo.moneypouch.app
cnn.com
jepsen.io
x.com
indiatoday.in
github.com
All the ideas came from the boot sector demo scene where people had been writing chess and BASIC games in 512 bytes, even a C compiler. I wondered what one can do using a neural network instead of a program and generating boot logs for non-existent hardware was something fun to try. Entire inference engine is 510 bytes of MBR, weights, vocab, and strings reside in the sectors following MBR. Small char-level neural network was trained on dmesg generated by machine, so machine produces Linux boot messages infinitely. train.py performs precisely the same integer arithmetic operations as the asm code does and thus produces an output identical character-by-character to the one produced by QEMU. The difference analysis revealed my favorite bug. The characters at the beginning matched those generated by the simulator, but then the output diverged. I retrieved the hidden layer via QEMU’s debug port and compared the neurons' values with those of the simulator, one neuron at a time. Only the value of the first neuron was correct. The activation involves idiv, and idiv stores its remainder in edx. The pointer to the biases table was stored in edx, which resulted in the first neuron being biased correctly and the following ones using garbage. Now the bias' address is determined from the loop counter, and no pointers have to survive the division. Another bug I found simply by looking at the code before I did my first run-through: the BIOS print routine zeros out bx, but bx contains the predicted character number. This explains the push and pop of bx surrounding the print. sectorllm is the most similar to my project, as it runs an actual 5-layer llama2 with attention mechanism in just 1.2K of assembly code. It is the trade-off in the opposite direction, as my engine needs to fit into one sector and therefore my network has just one hidden layer of int8 operations for dreaming the dmesg.
newrepublic.com
thebignewsletter.com
nullprogram.com