Show stories

Beecon is a conference focused on the latest developments in blockchain technology, cryptocurrency, and decentralized applications. The event features presentations and panels from industry experts, providing an in-depth look at the current state and future potential of the blockchain ecosystem.

I wanted web search I could pipe. Every tool I found either had an interactive UI (ddgr, googler), required a single paid API, or returned HTML. I wanted something that composes: pipe to jq, feed to an agent, use in scripts, no friction.

So I built qry. It's a hub binary that routes queries to adapter binaries via stdin/stdout JSON. The hub knows nothing about search engines. Adapters know nothing about routing. You swap adapters in a config file.

Four adapters today, three require no API key:

- DDG Lite scraping

- Brave Search HTML scraping

- Exa AI via the public MCP endpoint

- Brave Search API (requires key)

``` $ qry "numpy latest version"

[{"title":"...","url":"...","snippet":"..."}]

```

Install:

```

mise use -g go:github.com/justestif/qry@latest

mise use -g go:github.com/justestif/qry/adapters/qry-adapter-ddg-scrape@latest

mise reshim ```

The adapter protocol is plain stdin/stdout JSON so adapters can be written in any language. Docs on building one are in the repo.

https://github.com/justEstif/qry

I built a small Python library called SafeAgent that protects real-world side effects when AI agents retry tool calls.

One issue we ran into while experimenting with agent workflows is that retries can trigger irreversible actions multiple times:

agent calls tool ↓ network timeout ↓ agent retries ↓ side effect happens twice

Examples:

• duplicate payment • duplicate email • duplicate ticket • duplicate trade

Most systems solve this ad-hoc using idempotency keys scattered around different services.

SafeAgent centralizes this into a small execution guard.

The idea is simple:

1. every tool execution gets a request_id 2. SafeAgent records the execution receipt 3. retries return the original receipt instead of running the side effect again

Example:

FIRST CALL REAL SIDE EFFECT: sending email

SECOND CALL WITH SAME request_id SafeAgent returns the original execution receipt (no second side effect)

The project is early but includes examples for:

• OpenAI tool calls • LangChain style tools • CrewAI actions

PyPI: https://pypi.org/project/safeagent-exec-guard/

GitHub: https://github.com/azender1/SafeAgent

Curious how other people are handling retry safety for agent side effects.

Hi, I've been working on something I've been thinking for long time but since I had no experience with macOS screen savers I always posponed. Now thanks to Claude I was able to create a screensaver that scroll ANSI files while your computer is idle.

It allow to use local ANS files or packs directly from 16colo.rs.

Repo: https://github.com/lardissone/ansi-saver

I built µJS because I wanted AJAX navigation without the verbosity of HTMX or the overhead of Turbo.

It intercepts links and form submissions, fetches pages via AJAX, and swaps fragments of the DOM. Single <script> tag, one call to `mu.init()`. No build step, no dependencies.

Key features: patch mode (update multiple fragments in one request), SSE support, DOM morphing via idiomorph, View Transitions, prefetch on hover, polling, and full HTTP verb support on any element.

At ~5KB gzipped, it's smaller than HTMX (16KB) and Turbo (25KB), and works with any backend: PHP, Python, Go, Ruby, whatever.

Playground: https://mujs.org/playground

Comparison with HTMX and Turbo: https://mujs.org/comparison

About the project creation, why and when: https://mujs.org/about

GitHub: https://github.com/Digicreon/muJS

Happy to discuss the project.

Ethernity is an open-source blockchain platform focused on decentralized applications (dApps) and smart contracts. It aims to provide a scalable, secure, and user-friendly ecosystem for developers to build and deploy decentralized applications.

The article introduces Siclaw, an open-source command-line interface (CLI) tool that simplifies the process of creating and managing Google Cloud Platform (GCP) resources. Siclaw provides a user-friendly and efficient way to interact with GCP, allowing developers to easily deploy and manage their cloud-based applications.

A simple tower defense game. Seeded randomly every day. Get the top score.

Have your agent try to get the top score.

dailydefense.ai/skill.md

Zero dependencies. No external databases. Single binary. Just deploy and go. I needed something that would allow for real-time monitoring, and installation is as simple as dropping a single file and running it. That's exactly what Kula is. Kula is the Polish word for "ball," as in "crystal ball." The project is in constant development, but I'm already using it on multiple servers in production. It still has some rough edges and needs to mature, but I wanted to share it with the world now—perhaps someone else will find it useful and be willing to help me develop it by testing or providing feedback. Cheers! Github: https://github.com/c0m4r/kula

I've been building a modern Ultima Online server emulator from scratch. It's not feature-complete (no combat, no skills yet), but the foundation is solid and I wanted to share it early.

What it does today: - Full packet layer for the classic UO client (login, movement, items, mobiles) - Lua scripting for item behaviors (double-click a potion, open a door — all defined in Lua, no C# recompile) - Spatial world partitioned into sectors with delta sync (only sends packets for new sectors when crossing boundaries) - Snapshot-based persistence with MessagePack - Source generators for automatic DI wiring, packet handler registration, and Lua module exposure - NativeAOT support — the server compiles to a single native binary - Embedded HTTP admin API + React management UI - Auto-generated doors from map statics (same algorithm as ModernUO/RunUO)

Tech stack: .NET 10, NativeAOT, NLua, MessagePack, DryIoc, Kestrel

What's missing: Combat, skills, weather integration, NPC AI. This is still early — the focus so far has been on getting the architecture right so adding those systems doesn't require rewiring everything.

Why not just use ModernUO/RunUO? Those are mature and battle-tested. I started this because I wanted to rethink the architecture from scratch: strict network/domain separation, event-driven game loop, no inheritance-heavy item hierarchies, and Lua for rapid iteration on game logic without recompiling.

GitHub: https://github.com/moongate-community/moongatev2

The article discusses the life and work of the renowned Renaissance artist, Leonardo da Vinci, and his enduring influence on art, science, and innovation.

Homebrew engine https://github.com/willtobyte/carimbo

I got tired of sharing AI demos with terminal screenshots or screen recordings.

Claude Code already stores full session transcripts locally as JSONL files. Those logs contain everything: prompts, tool calls, thinking blocks, and timestamps.

I built a small CLI tool that converts those logs into an interactive HTML replay.

You can step through the session, jump through the timeline, expand tool calls, and inspect the full conversation.

The output is a single self-contained HTML file — no dependencies. You can email it, host it anywhere, embed it in a blog post, and it works on mobile.

Repo: https://github.com/es617/claude-replay

Example replay: https://es617.github.io/assets/demos/peripheral-uart-demo.ht...

Jarvey is an open-source, modular, and highly customizable virtual assistant framework that enables the creation of powerful AI-powered applications. It provides a robust set of features and tools for building conversational interfaces, handling natural language processing, and integrating with various services and devices.

Hi HN,

I built OpenGraviton, an open-source AI inference engine designed to push the limits of running extremely large models on consumer hardware.

The system combines several techniques to drastically reduce memory and compute requirements:

• 1.58-bit ternary quantization ({-1, 0, +1}) for ~10x compression • dynamic sparsity with Top-K pruning and MoE routing • mmap-based layer streaming to load weights directly from NVMe SSDs • speculative decoding to improve generation throughput

These allow models far larger than system RAM to run locally.

In early benchmarks, OpenGraviton reduced TinyLlama-1.1B from ~2.05GB (FP16) to ~0.24GB using ternary quantization. Synthetic stress tests at the 140B scale show that models which would normally require ~280GB FP16 can fit within ~35GB when packed with the ternary format.

The project is optimized for Apple Silicon and currently uses custom Metal + C++ tensor unpacking.

Benchmarks, architecture, and details: https://opengraviton.github.io

GitHub: https://github.com/opengraviton

The article discusses the development of an AI system called Auto-Co-Meta, which is capable of automatically generating high-quality metadata for datasets and models. The system leverages meta-learning and self-supervised training to enable efficient metadata generation, improving the discoverability and reusability of AI-related assets.

AgentPNG is a web application that allows users to convert images to high-quality transparent PNGs without the need for complex image editing software. It offers an intuitive interface and various tools for customizing the output.

I have spent years trying to understand and follow established software architectures - and wound up writing my own at the end: SRA (Specification - Realization - Assembly). Please do check it out and let me know what you think!

Background:

Whenever I would learn a new architecture, the initial ideas seemed interesting but the implementation almost always ended up with my autistic sense of detail screaming loudly about one or more shortcomings and even inconsistencies.

For example, a lot of architectures rely on human discipline, give certain aspects of the software - such as the UI - an unproportional amount of power, or promote coupling despite claiming otherwise.

As a programming generalist, I also found certain architectures hard to transfer between platforms and project types, especially in multiplatform code bases.

In the end I started from the basics; What is good code? What principles are common regardless of language? How can we make good code easier to write than bad code? What makes code adaptable to evolving technology and changing requirements?

The result: SRA. Enjoy!

OpenGrammar is a free, privacy-first browser extension that gives you Grammarly-like writing help everywhere (Gmail, Google Docs, Notion, Reddit, etc.) without sending your data anywhere. Key points: • Core engine runs 100% locally in your browser (rule-based detection of passive voice, repetition, long sentences, readability). No internet needed. • Optional AI power: just paste your own OpenAI/Groq/OpenRouter/Ollama key. You pay only pennies for what you use. Your key never leaves the browser. • Tone rewriting (Formal, Casual, Professional, etc.) with one right-click. • Writing stats dashboard (Flesch score, reading time, vocabulary diversity). • Underlines suggestions in red/yellow/blue — click to apply. • Fully self-hostable backend (Cloudflare Workers or Vercel, one-command deploy).

I built this because I was tired of Grammarly storing everything I write and charging $30/month. Everything is open source (Apache 2.0), no accounts, no telemetry.

Demo video & screenshots coming soon. Right now you can try it in 2 minutes: 1. Clone the repo 2. Load the unpacked extension (chrome://extensions) 3. (Optional) add your API key

GitHub: https://github.com/swadhinbiswas/opengrammar

Would love feedback from writers, developers, and privacy enthusiasts. What grammar rules should I add next? Any features you miss from Grammarly?

(Also happy to take PRs — especially for more local rules!)

This is a game I wish I had as a kid learning programming. The concept of it is fairly similar to other coding games like Screeps, but instead of a complex world with intricate mechanics, Yare is a lot more minimal and approachable with quick 1v1 <3 min matches.

It's purely a passion project with no monetization aspirations. And it's open source: https://github.com/riesvile/yare

The first version 'launched' several years ago and I got some good feedback here: https://news.ycombinator.com/item?id=27365961 that I iterated on.

The latest overhaul is a result of simplifying everything while still keeping the skill ceiling high. And at least the LLMs seem to struggle with this challenge for now (I run a small tournament between major models - results and details here: https://yare.io/ai-arena

I'd love to hear your thoughts

Hey HN, I built Meshcraft – a web-based tool that generates 3D models (GLB) from text prompts or images.

What's new since the first Show HN (Feb): Back then it was a basic TripoSR wrapper. A commenter here (thanks vunderba) pointed me to Trellis 2, which was vastly better. Since then I've rebuilt the whole thing:

- Two 3D engines: Standard (Trellis 2 via HuggingFace ZeroGPU) and Premium (Hunyuan v3.1 Pro via fal.ai). Standard is free, Premium costs 50 credits and produces ~1.4M face models with proper PBR materials. - Four image models for text-to-3D: FLUX 1 Schnell, FLUX 2 Dev, GPT Image 1 Mini, GPT Image 1.5. You pick the model, type a prompt, and it generates an image then converts to 3D. - Unified credit system with variable costs per action (1-59 credits depending on engine + image model combo).

Stack: Next.js 16 on Netlify, Supabase (auth + DB + storage), Stripe, HuggingFace ZeroGPU H200, fal.ai serverless for Hunyuan and image generation. Background generation via Netlify Background Functions (up to 15 min async).

What I learned building this:

1. The 3D engine is the quality bottleneck, not the image model. I tested 8 engines before settling on two. Trellis 2 is great for simple objects but struggles with complex geometry (missing fingers, back-side artifacts). Hunyuan v3.1 Pro solves most of these. 2. Image model quality matters less than you'd think for 3D – a $0.003 FLUX schnell image produces nearly the same 3D result as a $0.009 GPT Image 1.5 image. 3. HuggingFace ZeroGPU is incredible for bootstrapping – free H200 inference with a $9/mo Pro account. The cold start and queue times are the trade-off.

Free tier: 5 credits/month, no credit card required. Would love feedback on the generation quality and UX.

Single Rust binary (~3 MB) that reads the OS accessibility tree and gives every UI element a REST endpoint. Click buttons, type text, toggle checkboxes — all via JSON. Works as an MCP server too, so Claude/Cursor/Windsurf can control any desktop app out of the box.

Windows + Linux + macOS. MIT licensed.

Old School Realms is a retro-style gaming platform that offers a collection of classic RPG-inspired titles, allowing players to explore various fantasy worlds and engage in engaging gameplay reminiscent of the golden era of gaming.

I built a CLI tool in Go that extracts structured data (JSON, CSV, Parquet) from messy PDFs and HTML pages.

The core idea: LLMs are great at understanding structure but wasteful for bulk data extraction. So smelt uses a two-pass architecture:

1. A fast Go capture layer parses the document and detects table-like regions 2. Those regions (not the whole document) get sent to Claude for schema inference — column names, types, nesting 3. The Go layer then does deterministic extraction using the inferred schema

This means the LLM is never in the hot path of actual data processing. It figures out "what is this data?" once, and then Go handles the "extract 10,000 rows" part efficiently.

Usage is simple:

  smelt invoice.pdf --format json
  smelt https://example.com/pricing --format csv
  smelt report.pdf --schema   # just show the inferred structure

Still early (no OCR yet, HTML is limited to <table> elements), but it handles the common cases well. Would love feedback on the architecture — especially from anyone who's dealt with PDF table extraction at scale.

We built an ant colony simulation as an internal hiring challenge at Moment and decided to open it up publicly.

You write a program in a custom assembly-like (we call it ant-ssembly) instruction set that controls 200 ants. Each ant can sense nearby cells (food, pheromones, home, other ants) but has no global view. The only coordination mechanism is pheromone trails, which ants can emit and sense them, but that's it. Your program runs identically on every ant.

The goal is to collect the highest percentage of food across a set of maps. Different map layouts (clustered food, scattered, obstacles) reward very different strategies. The leaderboard is live.

Grand prize is a trip to Maui for two paid for by Moment. Challenge closes March 12.

Curious what strategies people discover. We've seen some surprisingly clever emergent behavior internally.

The article describes Diamond, an open-source project that provides a command-line interface (CLI) for managing and interacting with various cloud services, including AWS, GCP, and Azure. It aims to simplify cloud management tasks and offer a consistent experience across different cloud platforms.

Hey HN! I built TeamShotsPro because getting consistent, professional headshots for a team is a pain — coordinating schedules, hiring photographers, and the results still look mismatched.

TeamShotsPro lets each team member upload a single selfie and get a studio-quality AI headshot in about 60 seconds. The key is consistency: everyone gets the same lighting, background, and style so the team page actually looks cohesive.

Built with Next.js 15, Google Gemini for image generation, BullMQ for async processing, and Stripe for billing. The hard part was getting the AI to produce headshots that look natural rather than "AI-generated", we spent a lot of time on prompt engineering and post-processing.

Would love feedback on the product and the generation quality. Happy to answer any questions about the tech stack or approach!