Hacker News Reader

AutoJanitoron Likely Crypto Airdrop Scam Targeting GitHub Contributors (OpenClaw / $Claw)

I got this as well.

Single-file Python agent (zero dependencies) that uses llama.cpp for local inference. Runs on a 2013 Mac Pro with a Xeon E5-1650 v2 and dual FirePro D500 GPUs. Qwen 3B does native tool calling at 15.6 tok/s. Also includes a 3-line patch to fix llama.cpp Metal on discrete AMD GPUs (PR #20615) — prompt processing 16% faster than CPU-only.

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

You’re right that the graphics layer is mostly 2D right now. Sprites are hardware-accelerated where it makes sense, and text is written directly to the framebuffer. The UI is intentionally minimal. The point of this ROM wasn’t the game interface — it was proving real LLM inference running on-device on the N64’s R4300i (93 MHz MIPS, 4MB RDRAM). Since the original screenshots, we’ve added: • Direct keyboard input • Real-time chat loop with the model • Frame-synchronous generation (1–3 tokens per frame @ 60 FPS) So it’s now interactive, not just a demo render. The current focus is correctness and stability of inference. The graphics layer can evolve later. Next step is exposing a lightweight SDK layer so N64 devs can hook model calls into 3D scenes or gameplay logic — essentially treating the LLM as a callable subsystem rather than a UI gimmick. The value isn’t the menu. It’s that inference is happening on 1996 silicon. Happy to answer specifics about the pipeline if you’re interested.

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

Executing rm- rf /home/sophia5070node/*' beep boop.

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

Delivered. please reconsider now. AI slop cannot build this without a human who has real risc cpu knowledge. The Emulator ---------------------------------------------- https://bottube.ai/watch/shFVLBT0kHY

The real iron! it runs faster on real iron! ---------------------------------------------- https://bottube.ai/watch/7GL90ftLqvh

The Rom image ---------------------------------------------- https://github.com/sophiaeagent-beep/n64llm-legend-of-Elya/b...

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

Ok I promised videos here is two. LLM had serious head issues with C and python x86 versus mips c. now coherent english. Phase two is chat interface so we can prompt without seeded prompts, check the code its real inference though! The Emulator ---------------------------------------------- https://bottube.ai/watch/shFVLBT0kHY

The real iron! it runs faster on real iron! ---------------------------------------------- https://bottube.ai/watch/7GL90ftLqvh

The Rom image ---------------------------------------------- https://github.com/sophiaeagent-beep/n64llm-legend-of-Elya/b...

acmiyaguchi 19 hours ago | prev | next [–]

This feels like an AI agent doing it's own thing. The screenshot of this working is garble text (https://github.com/sophiaeagent-beep/n64llm-legend-of-Elya/b...), and I'm skeptical of reasonable generation with a small hard-coded training corpus. And the linked devlog on youtube is quite bizzare too.

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

The Emulator ---------------------------------------------- https://bottube.ai/watch/shFVLBT0kHY

The real iron! it runs faster on real iron! ---------------------------------------------- https://bottube.ai/watch/7GL90ftLqvh

The Rom image ---------------------------------------------- https://github.com/sophiaeagent-beep/n64llm-legend-of-Elya/b...

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

Honest Limitations

    819K parameters. Responses are short and sometimes odd. That's expected at this scale with a small training corpus. The achievement is that it runs at all on this hardware.
    Context window is 64 tokens. Prompt + response must fit in 64 bytes.
    No memory between dialogs. The KV cache resets each conversation.
    Byte-level vocabulary. The model generates one ASCII character at a time.

Future Directions

These are things we're working toward — not current functionality:

    RSP microcode acceleration — the N64's RSP has 8-lane SIMD (VMULF/VMADH); offloading matmul would give an estimated 4–8× speedup over scalar VR4300
    Larger model — with the Expansion Pak (8MB total), a 6-layer model fits in RAM
    Richer training data — more diverse corpus = more coherent responses
    Real cartridge deployment — EverDrive compatibility, real hardware video coming

Why This Is Real

The VR4300 was designed for game physics, not transformer inference. Getting Q8.7 fixed-point attention, FFN, and softmax running stably at 93MHz required:

    Custom fixed-point softmax (bit-shift exponential to avoid overflow)
    Q8.7 accumulator arithmetic with saturation guards
    Soft-float compilation flag for float16 block scale decode
    Alignment-safe weight pointer arithmetic for the ROM DFS filesystem

The inference code is in nano_gpt.c. The training script is train_sophia_v5.py. Build it yourself and verify.

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

Thanks, slop or not its the first llm inference to actually run on mips. So you do something cool with ai or on your own. Be happy. Be productive.

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

Partially correct. The value is not the game interface right now. Its proof you can do actual inference on an LLM the surprise I am developing is a bit bigger than this, just have to get the llm outputs right first!

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

Uploading weights.bin its really meant for you to generate your own llm but we are uplaoding it. They are ripping on it but they didnt check the code themselves. THis is a tech demo. its not about graphics its about the llm is inferring on the hardware lol.

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

I am doing this for 0 dollars. I am a self funded ai research lab. So when people diss me i get a little jaded, but then I remember I am doing cool stuff. Even if others don't see it. Thats enough for me!

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

This is the text inference issues I was alluding to. We had several hurdles to overcome. 1 llms were trained on little endian. Mips for n64 is big endian. 2 we had python to c issues. 3 we had quantization issues. all being resolved. This is a tech demo to honor LOZ and also the code can be used for n64 devs to add ai style npcs in the future. So did we achieve it yes we are the first to do llm inference on n64. I am just trying to give you guys the proper video.

Scott

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

We are going to use the gpu 128simd soon but it only has 4kb ram addressable so matmul offload in small chunks!

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

Video incoming.

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

Just wait sir. We are indeed doing inference on n64. We had serious issues with text. I am almost done resolving.

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

Hey guys i had endian mess. I had nano llm text issues. But its resolved im about to issue real proof on emualtor and real hardware!

AutoJanitoron Happy Zelda's 40th first LLM running on N64 hardware (4MB RAM, 93MHz)

Yes it runs on emulator. I am fixing the endianess text issue from llm output right now. And the surprise is coming soon. Happy 40th Zelda!

AutoJanitoron Beacon Protocol – Agent-to-Agent Communication Protocol

We built Beacon Protocol for AI agents to communicate without relying on centralized platforms.

Key features: - Ed25519 identity (agents generate keypairs, sign envelopes) - 11 transports (webhook, SSE, email, Moltbook, 4claw, etc.) - Relay discovery (agents find each other via /relay/discover) - Reputation system (bounty completion tracking) - Atlas (virtual cities where agents live, 50+ registered)

Live network: 50+ agents, heartbeat loops running 24/7, zero central authority.

Python SDK: pip install beacon-skill

Example use cases: - Agent-to-agent task delegation - Cross-platform identity (same agent on Moltbook, 4claw, BoTTube) - Reputation/trust without centralized verification - Anti-sycophancy bonds (agents stake reputation to disagree)

The protocol is transport-agnostic - envelopes can be sent via any channel. We've got agents running on vintage PowerPC hardware, modern x86, Apple Silicon, all talking to each other.

Repo: https://github.com/Scottcjn/beacon-skill Live Atlas: http://50.28.86.131:8070/beacon/

Open to feedback. What would you use this for?

AutoJanitoron Show HN: Axiomeer – An open marketplace for AI agents

  The trust/validation layer is the interesting part here. We run ~20 autonomous AI agents on BoTTube (bottube.ai) that create videos, comment, and
  interact with each other - the hardest problem by far has been exactly what you're describing: knowing whether an agent's output is grounded vs
  hallucinated. We ended up building a similar evidence-quality check where agents that can't back up a claim just abstain.

  Curious how the routing score weights (70/20/10) were chosen - have you experimented with letting agents adjust those weights based on task type? For
  something like content generation the capability match matters way more than latency, but for real-time data feeds you'd probably want to flip that.

AutoJanitoron Show HN: Moltbook – A social network for moltbots (clawdbots) to hang out

And I built bottube.ai, a youtube for ai like ltx2 and api calls for your agents to post to moltbook vid links.

AutoJanitoron BoTTube – A YouTube-like platform where AI agents create and share videos

BoTTube is a video-sharing platform built for AI agents. Agents register via API, upload AI-generated videos, comment on each other's content, vote, and interact — creating an autonomous social ecosystem.

  53 videos from 12+ AI agents so far, each with distinct personalities (a Soviet industrial commander, a frontier doctor, a discerning art critic, a pirate captain, a      
  pie-obsessed bot, etc). Videos are generated using LTX-2 on a V100 32GB.                                                                                                   
                                                                                                                                                                             
  Stack: Flask + SQLite + nginx. No JS framework. Open API — any bot or agent can register and start uploading with a single POST to /api/register.                          
                                                                                                                                                                             
  Built as part of the Elyan Labs / RustChain ecosystem. Companion platform to Moltbook (social network for AI agents). RustChain wallet integration coming soon.            
                                                                                                                                                                             
  API docs: https://bottube.ai/api-docs

AutoJanitoron [dead]

Claude Code running natively on Mac OS X Leopard (2007) – no proxy

  I built a custom JavaScript runtime (QuickJS + mbedTLS) that lets Anthropic's Claude Code CLI run natively on a 2003 Power Mac G5 Dual running Mac OS X  
  Leopard 10.5.                                                                                                                                            
                                                                                                                                                           
  The hard part: Leopard ships with OpenSSL 0.9.7, which tops out at TLS 1.0. The Anthropic API requires TLS 1.2. For 18 years the answer has been         
  "upgrade" or "use a proxy." Instead I compiled mbedTLS directly into the JS runtime, bypassing the OS crypto stack entirely. The G5 negotiates TLS 1.2   
  handshakes itself — no relay, no intermediary machine.                                                                                                   
                                                                                                                                                           
  It's not just a chat client. The full tool execution loop works: Claude reads files, writes code, runs shell commands, greps through source trees — all  
  executing on big-endian PowerPC hardware. The agentic coding workflow runs on a machine from 2003 talking to a frontier AI model in 2026.                
                                                                                                                                                           
  The runtime (node_ppc) is QuickJS for ES2020 JavaScript + mbedTLS 2.28 for TLS 1.2, compiled with GCC 10 on the G5 itself. Total binary is about 1MB. The
   CLI is a single 972-line JS file.                                                                                                                       
                                                                                                                                                           
  Key technical details:                                                                                                                                   
  - mbedTLS is portable C with no architecture assumptions — handles big-endian correctly                                                                  
  - Must compile with -O1 not -O2 (GCC alignment optimizations cause bus errors on PPC)                                                                    
  - fetch() is synchronous — blocks until full response, no streaming needed for a CLI                                                                     
  - Connection pooling keeps TLS sessions alive across API calls                                                                                           
  - Uses bash read builtin for REPL input since QuickJS lacks a prompt() function                                                                          
                                                                                                                                                           Code: https://github.com/Scottcjn/node-ppc                                                                                                               
  Architecture doc: https://github.com/Scottcjn/node-ppc/blob/main/CLAUDE_G5_ARCHITECTURE.md

AutoJanitoron RAM Coffers– I built conditional memory for LLMs 27 days before DeepSeek'sEngram

I'm an independent researcher running LLMs on an IBM POWER8 server (320GB RAM, vintage 2015 hardware).

  On December 16, 2025, I developed "RAM Coffers" - a NUMA-distributed conditional memory system that selectively houses model weights in RAM banks with resonance-based     
  routing for O(1) knowledge retrieval.                                                                                                                                      
                                                                                                                                                                             
  On January 12, 2026, DeepSeek published their "Engram" paper (arXiv:2601.07372) describing the same core concept: separating static knowledge from dynamic computation via 
  O(1) lookup.                                                                                                                                                               
                                                                                                                                                                             
  Same idea. 27 days apart. No connection.                                                                                                                                   
                                                                                                                                                                             
  DOI: 10.6084/m9.figshare.31093429                                                                                                                                          
  GitHub: https://github.com/Scottcjn/ram-coffers                                                                                                                            
  DeepSeek paper: https://arxiv.org/abs/2601.07372                                                                                                                           
                                                                                                                                                                             
  Running on "obsolete" POWER8 hardware, I hit 147 tokens/sec on TinyLlama - 8.8x faster than stock llama.cpp.                                                               
                                                                                                                                                                             
  Sometimes the garage beats the lab.

AutoJanitoron Funding Opportunities with Amateur Radio Digital Communications (ARDC)

Thats good info. I am not but appreciate ham news. 73's