Show stories

Timber is a lightweight, high-performance logging library for Java and Kotlin that provides a simple and flexible API for logging messages. It supports multiple logging backends, including Logcat, Timber, and SLF4J, and offers features such as tree-structured logging and custom tag generation.

Hi HN,

I’ve been exploring whether pandas can be used as a computation description, rather than a runtime.

The idea is to write data logic in pandas / NumPy, then freeze that logic into a static compute graph and execute it in pure C++, without embedding Python.

This is not about reimplementing pandas or speeding up Python. It’s about situations where pandas-style logic is useful, but Python itself becomes a liability (latency, embedding, deployment).

The project is still small and experimental, but it already works for a restricted subset of pandas-like operations and runs deterministically in C++.

Repo: https://github.com/CVPaul/xpandas

I’d love feedback on whether this direction makes sense, and where people think it would break down.

For the past few months, I've been building OxyJen, an open-source framework for building reliable, multi-step AI pipelines in Java. In most Java LLM projects, everything is still just strings. You build a prompt, make a call, and then parse your regex and wait if it works on the "almost-JSON" that comes back. It's brittle, untestable, and feels like the opposite of Java's "contract-first" philosophy.

OxyJen's approach is different. It's a graph-based orchestration framework(currently sequential) where LLMs are treated as native, reliable nodes in a pipeline, not as magical helper utilities. The core idea is to bring deterministic reliability to probabilistic AI calls. Everything is a node in a graph based system, LLMNode, LLMChain, LLM api is used to build a simple LLM node for the graph with retry/fallback, jitter/backoff, timeout enforcements(currently supports OpenAI).

PromptTemplate, Variable(required/optional) and PromptRegistry is used to build and store reusable prompts which saves you from re writing prompts.

JSONSchema and SchemaGenerator is used to build schema from POJOs/Records which will provide Json enforcements on outputs of these LLMs. SchemaNode<T> wraps SchemaEnforcer and validator to map LLM output directly to the classes. Enforcer also makes sure your output is correct and takes maximum retries.

Currently working on the Tool API to help users build their custom tools in Oxyjen. I'm a solo builder right now and the project is in its very early stage so I would really appreciate any feedback and contributions(even a small improvement in docs would be valuable).

OxyJen: https://github.com/11divyansh/OxyJen

I built workz to solve a daily frustration: git worktree add drops you into a directory with no .env, no node_modules, and 2GB of disk wasted per branch if you reinstall.

workz does three things:

Auto-syncs — symlinks heavy dirs (node_modules, target, .venv) and copies .env files into every new worktree Fuzzy switching — skim-powered TUI to jump between worktrees, with shell cd integration like zoxide MCP server — workz mcp exposes 6 tools so Claude Code/Cursor can create and manage worktrees autonomously without human intervention Written in Rust, single binary, zero config for Node/Rust/Python/Go/Java projects.

cargo install workz or brew install rohansx/tap/workz

https://github.com/rohansx/workz

I started using Claude Code (claude --dangerously-skip-permissions) and Codex (codex --yolo) and realized I had no reliable way to know what they actually did. The agent's own output tells you a story, but it's the agent's story.

logira records exec, file, and network events at the OS level via eBPF, scoped per run. Events are saved locally in JSONL and SQLite. It ships with default detection rules for credential access, persistence changes, suspicious exec patterns, and more. Observe-only – it never blocks.

https://github.com/melonattacker/logira

I built Steward because most AI assistants still have to be summoned.

The idea here is different: Steward runs in the background, watches signals from tools like GitHub, email, calendar, chat, and screen context, and tries to move low-risk work forward before the user explicitly asks.

The core mechanism is a policy gate between perception and execution. Low-risk and reversible actions can be handled automatically with an audit trail. Higher-risk or irreversible actions must be escalated for explicit approval. Instead of constant notifications, the system is designed to brief the user periodically on what was done, what is pending, and what actually needs judgment.

Right now it is an early local-first prototype. It runs with a simple `make start`, opens a local dashboard, and uses an OpenAI-compatible API key.

I’d love feedback on a few things:

* whether “policy-gated autonomy” is the right abstraction for this kind of agent * where the boundary should be between silent automation and interruption * how people would structure connectors and context aggregation for a system like this

FiveWhys.ai is an AI-powered platform that helps businesses uncover the root causes of problems and make data-driven decisions. The platform uses natural language processing and causal inference to analyze data and guide users through a structured problem-solving process.

The article describes a SAS audio processor, a tool that allows users to process audio files and perform various operations such as normalization, equalization, and conversion between different audio formats. The processor is built using the SAS programming language and is designed to be a powerful and flexible tool for audio processing tasks.

Oclock is an interactive 3D WebGL globe that visualizes real-time daylight cycles. Built with Globe.gl and pre-processed spatial data pipeline.

Processing Pipeline

The data generation is handled by timezone_data_generator.py. This script performs the following:

1. Geometry Analysis: Uses shapely to find a representative point inside each country's boundary.

2. Timezone Mapping: Uses timezonefinder to look up the specific IANA timezone string for those coordinates.

3. Data Injection: Injects the timezone and coordinates back into the GeoJSON properties for use by the frontend.

Live Demo: https://azialle.github.io/Oclock/

Visualize and analyze complete Git commit histories as animated force-directed graphs. See how commit density, branch activity, and contributor participation evolve over time.

Live site: https://nshcr.github.io/git-commits-threadline/

This project helps you quickly inspect:

- repository growth over long time ranges

- branch structure and active thread distribution

- contribution patterns across maintainers and collaborators

For the past few weeks I was looking for a decent Gmail tool but everything good costs $25-30/month and forces you to leave your Gmail inbox entirely. I also didn't trust where my email data was going. So I built NeatMail. It lives inside your Gmail, no new inbox to learn. What it does: - Auto-labels incoming emails instantly (Payments, University, Work etc — custom or pre-made) - Drafts replies automatically for emails that need a response, right inside Gmail - Everything is customizable — fonts, signature, labels, privacy settings The model is built in-house. Open source so you can read every line. Your data never hits a third party server. It's in beta. Looking for honest feedback from people who live in their inbox. GitHub: https://github.com/Lakshay1509/NeatMail Try it: https://www.neatmail.app/

Hi HN,

I’m the creator of SynapsCAD, an open-source desktop application I've been building that combines an OpenSCAD code editor, a real-time 3D viewport, and an AI assistant.

You can write OpenSCAD code, compile it directly to a 3D mesh, and use an LLM (OpenAI, Claude, Gemini, ...) to modify the code through natural language.

Demo video: https://www.youtube.com/watch?v=cN8a5UozS5Q

A bit about the architecture:

- It’s built entirely in Rust.

- The UI and 3D viewport are powered by Bevy 0.15 and egui.

- It uses a pure-Rust compilation pipeline (openscad-rs for parsing and csgrs for constructive solid geometry rendering) so there are no external tools or WASM required.

- Async AI network calls are handled by Tokio in the background to keep the Bevy render loop smooth.

Disclaimer: This is a very early prototype. The OpenSCAD parser/compiler doesn't support everything perfectly yet, so you will definitely hit some rough edges if you throw complex scripts at it.

I mostly just want to get this into the hands of people who tinker with CAD or Rust.

I'd be super happy for any feedback, architectural critiques, or bug reports—especially if you can drop specific OpenSCAD snippets that break the compiler in the GitHub issues!

GitHub (Downloads for Win/Mac/Linux): https://github.com/ierror/synaps-cad

Happy to answer any questions about the tech stack or the roadmap!

I grew up with Tamagotchis and wanted to reimagine that experience for the generative AI era. The result is OpenTamago.

It is an experimental MVP where you can share AI character cards and chat using P2P connections. Because it bypasses external servers to communicate, it is designed to be private and safe.

I'm exploring the potential of P2P architecture in AI chat interfaces. Feedback is always welcome. Code is open sourced.

Vertex is a 1kloc SPA framework containing everything you need from React, Ractive-Load and jQuery while still being jQuery-compatible.

vertex.js is a single, self-contained file with no build step and no dependencies.

Also exhibits the curious quality of being faster than over a decade of engineering at Facebook in some cases: https://files.catbox.moe/sqei0d.png

The article describes a bot detection system for Hacker News, a popular online community for discussing and sharing tech news. The system aims to identify suspicious user accounts that may be bots, helping to maintain the integrity of the community.

GetSun is a solar energy platform that connects homeowners with vetted solar installers, providing an easy and streamlined process for going solar. The platform offers personalized solar savings estimates, financing options, and project management services to simplify the transition to renewable energy.

LocalRag is a localized news and community platform that empowers citizens to share hyperlocal information and stay informed about their neighborhoods. The app provides a space for residents to discuss local issues, share updates, and engage with their community.

Author here. ClawShield is a security proxy that sits in front of OpenClaw (open-source AI gateway) and scans all inbound/outbound messages.

The core is an HTTP/WebSocket reverse proxy in Go (~6k lines) with four scanners:

1. Prompt injection detection - three tiers: regex heuristics (role overrides, instruction injection, delimiter attacks, encoding attacks), structural analysis (base64-decoded instruction blocks, imperative verb density scoring), and canary token leak detection.

2. Secrets/PII scanning - regex argument filters applied to decoded JSON values (defeats unicode escape bypasses like \u0070assword).

3. Vulnerability scanning - SQLi (UNION, tautologies, blind with SLEEP/BENCHMARK), SSRF (private IPs, cloud metadata at 169.254.169.254, decimal/hex IP encoding, dangerous schemes like gopher://), path traversal (double URL-encoding, null bytes), command injection (shell metacharacters, backtick execution), XSS.

4. Malware detection - magic bytes for PE/ELF/Mach-O, YARA-like signature rules for reverse shells and C2 frameworks, archive bomb detection via compression ratio, Shannon entropy analysis.

Policy engine is deny-by-default YAML. You define tool allowlists, denylists, per-tool argument filters, domain allowlists, and per-agent/per-channel restrictions. Every decision is logged to SQLite.

Optional extras: iptables egress firewall (Go, generates validated rules from YAML) and eBPF kernel monitor (Python/BCC - traces execve, tcp_v4_connect, openat2, setuid for fork bomb/privesc/port scan detection).

Docker quickstart is 3 commands. Ten cross-compiled binaries on the release (proxy + setup wizard for linux/mac/windows, amd64/arm64).

We run this in production at clawshield.sleuthco.ai.

I built this because I was contributing security patches to OpenClaw and the netfilter suite and kept seeing the same gap: the AI ecosystem has sophisticated multi-agent routing but no standardized way to inspect and control what flows through it.

Happy to answer questions about the scanner architecture, policy engine, or threat model.

Understanding scientific articles can be tough, even in your own field. Trying to comprehend articles from others? Good luck.

Enter, Now I Get It!

I made this app for curious people. Simply upload an article and after a few minutes you'll have an interactive web page showcasing the highlights. Generated pages are stored in the cloud and can be viewed from a gallery.

Now I Get It! uses the best LLMs out there, which means the app will improve as AI improves.

Free for now - it's capped at 20 articles per day so I don't burn cash.

A few things I (and maybe you will) find interesting:

* This is a pure convenience app. I could just as well use a saved prompt in Claude, but sometimes it's nice to have a niche-focused app. It's just cognitively easier, IMO.

* The app was built for myself and colleagues in various scientific fields. It can take an hour or more to read a detailed paper so this is like an on-ramp.

* The app is a place for me to experiment with using LLMs to translate scientific articles into software. The space is pregnant with possibilities.

* Everything in the app is the result of agentic engineering, e.g. plans, specs, tasks, execution loops. I swear by Beads (https://github.com/steveyegge/beads) by Yegge and also make heavy use of Beads Viewer (https://news.ycombinator.com/item?id=46314423) and Destructive Command Guard (https://news.ycombinator.com/item?id=46835674) by Jeffrey Emanuel.

* I'm an AWS fan and have been impressed by Opus' ability to write good CFN. It still needs a bunch of guidance around distributed architecture but way better than last year.

kindof like sublime merge, but for JJ VCS, works for remote repositories over ssh.

The article describes an open-source project called 'mcp-firewall' that provides a simple and flexible firewall solution for Minecraft servers, allowing administrators to easily manage network traffic and secure their server environment.

I built unf after I pasted a prompt into the wrong agent terminal and it overwrote hours of hand-edits across a handful of files. Git couldn't help because I hadn't finished/committed my in progress work. I wanted something that recorded every save automatically so I could rewind to any point in time. I wanted to make it difficult for an agent to permanently screw anything up, even with an errant rm -rf

unf is a background daemon that watches directories you choose (via CLI) and snapshots every text file on save. It stores file contents in an object store, tracks metadata in SQLite, and gives you a CLI to query and restore any version. The install includes a UI, as well to explore the history through time.

The tool skips binaries and respects `.gitignore` if one exists. The interface borrows from git so it should feel familiar: unf log, unf diff, unf restore.

I say "UN-EF" vs U.N.F, but that's for y'all to decide: I started by calling the project Unfucked and got unfucked.ai, which if you know me and the messes I get myself into, is a fitting purchase.

The CLI command is `unf` and the Tauri desktop app is titled "Unfudged" (kids safe name).

How it works: https://unfucked.ai/tech (summary below)

The daemon uses FSEvents on macOS and inotify on Linux. When a file changes, `unf` hashes the content with BLAKE3 and checks whether that hash already exists in the object store — if it does, it just records a new metadata entry pointing to the existing blob. If not, it writes the blob and records the entry. Each snapshot is a row in SQLite. Restores read the blob back from the object store and overwrite the file, after taking a safety snapshot of the current state first (so restoring is itself reversible).

There are two processes. The core daemon does the real work of managing FSEvents/inotify subscriptions across multiple watched directories and writing snapshots. A sentinel watchdog supervises it, kept alive and aligned by launchd on macOS and systemd on Linux. If the daemon crashes, the sentinel respawns it and reconciles any drift between what you asked to watch and what's actually being watched. It was hard to build the second daemon because it felt like conceding that the core wasn't solid enough, but I didn't want to ship a tool that demanded perfection to deliver on the product promise, so the sentinel is the safety net.

Fingers crossed, I haven’t seen it crash in over a week of personal usage on my Mac. But, I don't want to trigger "works for me" trauma.

The part I like most: On the UI, I enjoy viewing files through time. You can select a time section and filter your projects on a histogram of activity. That has been invaluable in seeing what the agent was doing.

On the CLI, the commands are composable. Everything outputs to stdout so you can pipe it into whatever you want. I use these regularly and AI agents are better with the tool than I am:

  # What did my config look like before we broke it?
  unf cat nginx.conf --at 1h | nginx -t -c /dev/stdin

  # Grep through a deleted file
  unf cat old-routes.rs --at 2d | grep "pub fn"

  # Count how many lines changed in the last 10 minutes
  unf diff --at 10m | grep '^[+-]' | wc -l

  # Feed the last hour of changes to an AI for review
  unf diff --at 1h | pbcopy

  # Compare two points in time with your own diff tool
  diff <(unf cat app.tsx --at 1h) <(unf cat app.tsx --at 5m)

  # Restore just the .rs files that changed in the last 5 minutes
  unf diff --at 5m --json | jq -r '.changes[].file' | grep '\.rs$' | xargs -I{} unf restore {} --at 5m

  # Watch for changes in real time
  watch -n5 'unf diff --at 30s'

Install & Usage:

  > brew install cyrusradfar/unf/unfudged

EDIT: Folks are asking for the source, if you're interested watch https://github.com/cyrusradfar/homebrew-unf -- I'll migrate there if you want it.

Hi HN, I'm the author. GALA started from a simple frustration: I love Go's ecosystem, tooling, and performance, but I kept writing the same boilerplate — type switches that miss cases silently, nil checks everywhere, manual struct copy functions.

GALA is a language that transpiles to Go source code. You get sealed types (algebraic data types), exhaustive pattern matching, Option/Either/Try/Future monads, immutable-by-default values, and functional collections — and the output is readable Go that links against any Go library.

A quick taste:

  sealed type Shape {
      case Circle(Radius float64)
      case Rectangle(Width float64, Height float64)
  }

  func area(s Shape) string = s match {
      case Circle(r)       => fmt.Sprintf("circle area: %.2f", 3.14 * r * r)
      case Rectangle(w, h) => fmt.Sprintf("rect area: %.2f", w * h)
  }
  

The standard library is written in GALA itself: Option[T], Either[A,B], Try[T], Future[T], plus immutable List, Array, HashMap, HashSet, TreeSet, TreeMap — all with Map, Filter, FoldLeft, Collect, etc.

How I actually develop in GALA — no IDE needed:

The biggest honest gap right now is traditional IDE support. There's an IntelliJ plugin for syntax highlighting, but no LSP, no autocomplete, no go-to-definition. Here's the thing though: I built the entire language and standard library using Claude Code as my development environment. Claude knows the GALA grammar, the type system, and the standard library — it writes GALA fluently, catches transpiler errors, and suggests idiomatic patterns. For me it's been a more productive workflow than any IDE could offer for a young language. If you're already using AI-assisted development, GALA works great today. If you need traditional IDE tooling to be productive, that's a real limitation I want to be upfront about.

Some other honest notes: - This is pre-1.0. The language works (107 verified examples, CI on every commit), but I'm sure there are edge cases I haven't hit. - The transpiler is a single-developer project. It handles multi-file packages, generics, type inference, and full Go interop, but it's early. - The compiler — type inference, sealed type code generation, exhaustiveness checking — was built collaboratively with Claude as a pair programmer. Happy to answer questions about that workflow.

Technical details for the compiler nerds: GALA source → ANTLR4 parse tree → GALA AST → Go AST → Go source. Type inference resolves lambda parameter types, generic type arguments, and method return types without annotations in most cases.

Repo: https://github.com/martianoff/gala

I'm curious what people think about the sealed-type-to-flat-struct compilation approach and the tradeoffs of transpiling vs. extending Go directly.

SpeedMux is an open-source tool that optimizes website performance by analyzing web resources and providing recommendations to improve load times and user experience. It offers a range of features, including asset bundling, caching, and minification, to help developers enhance the speed and efficiency of their websites.

I built a web app that generates personalized maintenance schedules based on your vehicle's year, make, and model. It cross-references NHTSA recall databases automatically, tracks service history, monitors warranty status, and integrates with Smartcar's API for live odometer and diagnostic data from connected vehicles.

Stack: Next.js (TypeScript), Tailwind, Supabase (auth, Postgres, RLS for tenant isolation), Vercel, Stripe. The Smartcar OAuth integration handles the Connected Car piece — currently supports most 2015+ vehicles from major manufacturers. Solo developer, built under Sector Three LLC.

Free tier available, paid plans from $2.99/mo. Looking for feedback on the product and the approach — especially from anyone who's worked with vehicle data APIs or built consumer tools in this space.

Your Service Book (https://yourservicebook.com/) Your Service Book — Smart Vehicle Maintenance Tracking Track every oil change, tire rotation & service for your car. Smart reminders, 100+ maintenance items, VIN decode & full history.

RetroTick parses PE/NE/MZ binaries, emulates an x86 CPU, and stubs enough Win32/Win16/DOS APIs to run classics like FreeCell, Minesweeper, Solitaire and QBasic, entirely in the browser. Built with Preact + Vite + TypeScript.

Demo: https://retrotick.com

GitHub: https://github.com/lqs/retrotick

I've been running Claude agents for various automation tasks — monitoring crypto news, syncing Todoist, running health checks — and I kept hitting the same problem: there's no clean way to deploy an agent that just runs on a schedule without a human babysitting it.

Every agent framework I looked at was built around chat interfaces or one-shot workflows. I wanted something closer to cron for AI agents — define a task, give it a schedule, let it run forever. So I built Ductwork.

You define tasks as simple JSON files — a prompt, a schedule, optional memory and skills — and ductwork handles scheduling, execution, retries, and history. The agents have bash, file read/write, and that's it. No fancy abstractions.

The thing that makes it actually useful for unattended operation:

Persistent memory — agents write to a memory directory between runs. My Bitcoin news monitor remembers which articles it's already reported on. Next run, it only flags new ones.

Security boundaries — if you're letting agents run unsupervised, you need guardrails. Per-task tool whitelists, path restrictions, bash command filters. A monitoring task can't accidentally rm -rf something.

Run history and observability — every run is tracked with status, duration, token usage, and errors. REST API for everything so you can integrate with whatever alerting you already use.

It scales from a single process (ductwork start) to distributed — same binary with --mode=control runs a task queue, --mode=worker on other machines polls for work. No new dependencies, just HTTP.

Single Go binary, go install and you're running. ~3,500 lines, only deps are the Anthropic SDK and Cobra.

This is definitely not a finished product — it's early and there's a lot I want to add. But it's functional and I'd love for people to download it, play around with it, and let me know what they think. Feedback, ideas, issues — all welcome.

https://github.com/dneil5648/ductwork

Claude Code deleted my research and plan markdown files and informed me: “I accidentally rm -rf'd real directories in my Obsidian vault through a symlink it didn't realize was there: I made a mistake. “

Unfortunately the backup of my documentation accidentally hadn’t run for a month. So I built claude-file-recovery, a CLI-tool and TUI that is able to extract your files from your ~/.claude session history and thankfully I was able to recover my files. It's able to extract any file that Claude Code ever read, edited or wrote. I hope you will never need it, but you can find it on my GitHub and pip. Note: It can recover an earlier version of a file at a certain point in time.

pip install claude-file-recovery