2025年9月19日 的 Show HN

Writing Redis from scratch in Zig.

I've been working on this small, slightly weird expression-oriented programming language for a little while now and feel ready to share it with others. I use it pretty often now in my day-to-day and work life, as a scratchpad for doing a bit of quick math or picking some pieces of data out of a JSON payload.

Would really appreciate any feedback about the syntax, docs, features that are glaringly missing, etc. Before anybody mentions it: I know the performance is pretty lousy when dealing with a lot of data. If you can believe it, the runtime is about 100x faster than it used to be! Long term I'd like to switch to a proper bytecode interpreter, but so far performance has been Good Enough for my use cases.

Thanks for taking a look!

Nallely is about experimenting with signals: routing, patching, or writing small neurons that process signals and eventually sink in MIDI devices or any application connected to Nallely.

I try to get inspired by the "Systems as a Living Things" philosophy and aim, step by step, to create an auto-adaptive, resilient, distributed system. Currently, neurons live in their own thread in a session (world), and send signals (messages) to each other through patches (channels). You can also connect to a network-bus neuron to register your own neurons written in any other technology and have them interact with the existing neurons inside the world. Nallely offers an API to easily code your own reactive neurons, and provides a mobile-friendly GUI for patching everything visually.

As anyone posting something based on Python, I can already hear: "no, Python's bad, think about the performances, think about the children".

We all know about Python performances (we've all seen the animation with the moving balls and stuff), but the focus here is on dynamic and emergent behaviors, extensibility, and run time adaptability over extreme performance. Even though Nallely is written in pure Python, it runs on a Raspberry Pi 5 (ok, a powerful one), consuming less than 10% CPU on a normal usage and around 40MB of memory.

And, as someone mentioning Smalltalk, I can already hear: "Why didn't you write it in Smalltalk"? (replace Smalltalk by your prefered dialect)

I like Smalltalk, but I also like Python. Nailed it, perfect justification. Jokes aside, IMO Smalltalk is "Systems as Living Things" pushed at its extreme for designing a language, and I admire that. With Nallely, I want to explore the same philosophy: independent musical/signal-processing neurons, without relying on Smalltalk, while benefiting from Python's deployment and ecosystem advantages (compared to Smalltalk).

Still a bit of a WIP, but getting there...

Any feedback appreciated :)

We built an open source layer to orchestrate multiple Codex agents in parallel. Found myself and some friends running Codex agents across multiple terminals. Thats why me and a friend built emdash. Each agent gets its own isolated workspace, making it easy to see who’s working, who’s stuck, and what’s changed.

I used to run a startup back in 2018 where I built highly relevant prospect leads for companies manually.

This is an Ai agent that does what I used to do manually - source, curate, enrich, qualify leads, and find the right decision makers with contact information.

The Ai agent builds a custom database of leads automatically We just upgraded the new UI as well as made our agents smarter.

Check out the new website: https://kurationai.com/

Demo: https://youtu.be/KmlGnP3dzkE?si=N6FZwNubi70hS4nJ

Use "PHK15" to get 15% off on any plan.

Thanks, Aurelien, Founder, Kuration AI

Hi HN! I built RustNet, a Terminal UI based network monitor written in Rust that shows real-time connections with process identification and protocol detection.

What may make it interesting:

• Deep packet inspection for HTTP, HTTPS/TLS (with SNI), DNS, and QUIC protocol detection

• Process identification using eBPF on Linux (experimental) and PKTAP on macOS which does also catch short-lived processes that polling procfs or lsof would miss

• Multi-threaded packet processing with lock-free data structures for the UI

• Cross-platform (Linux, macOS, Windows but process identification so far only on Linux/macOS)

The eBPF implementation was a bit more tricky to implement than using PKTAP, but it was very interesting to learn about how to hook into tcp_connect, udp_sendmsg, etc. in order to catch process info before connections disappear.

I built this as a lightweight Wireshark alternative for quick TUI based network inspection with process identification.

Install: cargo build --release, run with sudo or set capabilities. Homebrew tap also available.

Would love feedback on the project and any ideas for additional protocol detection or any other suggestions. Thanks

Hi HN! I couldn’t find a truly user-friendly PlantUML editor, so I set out to build one.

PlantDiagrams lets you describe a diagram in plain English; it generates the PlantUML and renders it instantly. The goal is to shorten the path from idea → diagram without fighting the editor.

Tech: - Next.js / Supabase / FLy.io / Vercel

Highlights - Natural-language to PlantUML with live preview - Export diagrams (SVG/PNG/TXT) - Organize work with Projects - Share via link; optional comments for review - Sample gallery to open and tweak examples

Try it: https://www.plantdiagrams.com

Tired of manually copying tunnel URLs, API tokens, or other dynamic values into config files? Even small tasks like this break flow and are error-prone.

I built Devsyringe, a small Go CLI that automates this process. You define rules in a simple YAML file, run a command, and it updates multiple static files automatically.

It works for tunnels, API keys, documentation, CI/CD configs — anywhere dynamic values need injecting. I’d love to hear how others handle injecting dynamic values into static files in their workflows.

GitHub: https://github.com/alchemmist/devsyringe

We're sharing a free and public llms.txt generator and endpoint.

Our approach: we crawl your main page, then parse metatags and links to construct the llms.txt. The key is that this process happens without relying on any LLMs, which keeps it very fast and our operational costs extremely low. This allows us to offer it completely free.

Check it out on the homepage, or just send a GET request:

https://get.llms.page/{yourwebsite}/llms.txt

We'd appreciate any feedback or suggestions for features/improvements.

Got tired of saving my prompts scattered across X, Reddit, and Notion with no good way to organize or share them.

That's why I built CTX, a community collection of prompts and rules. Create, share, and remix – everything's free and community-curated.

Let me know what you think, any feedback is very welcome!

Hi HN,

My team have spent years as developers and operators, and we’ve been incredibly frustrated by a common, nagging problem: secure server access. We’ve all been there—the endless authorized_keys file management, the VPN configs that break at the worst possible time, or the constant fear that someone who left the team still has access to production. It’s an exhausting and friction-filled process that takes away from what we should actually be doing.

We looked for a better way, but every solution we found was either too complex, too expensive, or still relied on the same outdated methods. So, we decided to build our own. That's how Alpacon was born.

We designed Alpacon from the ground up to solve these pain points. It's a zero-trust platform that completely removes the need for SSH keys and VPNs. Our goal was to create a tool that is not only secure by default but also so simple that it gets out of your way.

Here’s how it works:

Instant Onboarding: Add a new team member and grant them secure, role-based access in seconds. No more key management.

Auditable Access: Every action is logged and auditable. You always know who is accessing what, and when.

Granular Control: Instead of broad firewall rules, you can define precise, least-privilege access policies for every user and resource.

We’re now opening our beta program to a small group of users. This isn't just about launching a product; it’s about starting a conversation and getting feedback from people who live and breathe this problem every day. Your insights will be invaluable in helping us shape Alpacon into the tool we all wish we had.

We’re genuinely excited to see how you use it and what you think.

I've been working on a ROS 2 package that detects route blockage signboards used in the Tsukuba Challenge. The approach relies entirely on point cloud data and intensity information from a 3D LiDAR sensor without camera input.

Hi HN!

I and two other colleagues have been building Summoner, a decorator-first Python SDK with a Rust relay for live, duplex agent-to-agent networking across machines. Basically, think MMO but for AI agents.

It's currently in early beta (v1.0) (expect a few sharp edges), but we have already built 25 template agents from which you can build your projects (hello world, question/answer, protocol handshakes, negotiation, etc.) ;

### What it is

- A tiny runtime where you write @receive / @send handlers and let the relay move messages between agents in real time. - Routes are simple strings that behave like labeled edges; the runtime compiles them into a small automaton so agents can coordinate without hand-building graphs.

### Why it’s different

1) Not a model-to-tool connector like MCP: Summoner focuses on agent-to-agent sessions and orchestration, not model-to-tool calls.

2) Not server-anchored agent executors like A2A: Summoner agents are mobile and duplex by default, so they can initiate/serve and move between relays without being wrapped as server executors.

3) Compared to LangChain/LangGraph, Summoner aims for less ceremony: you don't draw the graph, you just register handlers (MCP-like) and let routes drive the flow.

### What I'm looking for

- Critical feedback on the SDK (see https://github.com/Summoner-Network/summoner-docs)

- Where would you want MCP tools or A2A discovery layered in?

- Reliability/perf corners you would test first

- Security review of the state-machine approach

### Links

- Examples (start here): https://github.com/Summoner-Network/summoner-agents

- Docs / design notes: https://github.com/Summoner-Network/summoner-docs

- Core runtime: https://github.com/Summoner-Network/summoner-core

- Project page: https://summoner.org

GarlicSignage provides a suite of self-developed open-source software components that allow users to create custom digital signage solutions.

The concept is a modular system of individual building blocks that can be flexibly combined.

The following software components are currently available:

garlic-player: A media player for Windows, Linux, Android, and macOS is written in C++ with Qt lib. The playlists are based on w3c SMIL.

garlic-hub: A web-based CMS for managing content and controlling the media players. It is in PHP 8.4

garlic-launcher: An Android launcher that, together with the media player, enables a remotely manageable, root-free hardware solution. written in JAva

garlic-proxy: A transparent proxy solution for reducing bandwidth consumption written in PHP7.

Windows 11 enforces Control-flow Enforcement Technology (CET), which breaks many classical syscall stubs and ROP chains used in red teaming. I spent the last few months investigating whether attackers can still invoke syscalls in a CET-compliant way without tripping EDRs , and how defenders can close those gaps.

Within GhostSys, I formalized a post-CET syscall threat model, Five CET-compliant syscall invocation techniques (Ghost Syscalls, RBP Pivot, Speculative Probe, KCT Smuggle, eBPF JIT) with 12,000-call evaluation, 0 CET violations, no detections across three EDRs

You will also find defender-focused recommendations. Check it out!

Note > Some techniques within GhostSys are known - its supposed to be a systematic, reproducible study of CET-compliant syscall invocation and detection coverage, not cutting edge (eBPF jit had a similiar talk, SickCodes DEF CON talk), Specter vuln has been seen in the Pafish++, but not turned towards syscall hook detection. Gadget scanning is essentially a much more rigorous SysWhispers + Halos Gate.

Hey all,

I created a small git worktree utility some might find useful when creating worktrees so you can work on a few tasks in your code base in parallel

https://github.com/bnchrch/wt

------

Why did I create this?

------

Essentially raw worktrees are rough

1. You need to decide where in your file system to create them

2. Theres no connection back to the original local repo

3. Theres no way to copy or symlink untracked files (.env, build artifacts etc...)

I looked at existing worktree helpers and could not find anything that both

1. Let me create a branch + worktree and cd to the worktree in one command

2. Prune unused worktrees

3. Set what untracked files I wanted to "sync" and how

So I created my own

------

What does it do?

------

1. Introduces a `.worktree` file you can add to your project that defines:

  1. Where to create worktrees

  2. What files/folders to copy/symlink (e.g. `.env`)

  3. What commands to run when you create a new worktree (`npm install`)

2. Create a branch + worktree + cd to the folder in one command `wt switch <branch-name>`

3. Return to the root repo in one command `wt root`

4. Prune wt related to branches that no longer exist `wt prune --all`

----

Anyway, hope someone finds this useful, happy coding!

Hi HN!

We hear consistent complaints from academics, researchers, and scientists about AI chatbots having poor PDF awareness and often generating incorrect citations. This is bad for high-level researchers and people learning who need answers grounded in evidence.

We took the best parts of Cursor, like workspace awareness, @ symbol referencing, and human approval/oversight, and built a PDF browser with academic database searching (ArXiv and Semantic Scholar) + our Ubik agents that can highlight text down to the line level and use our "Detailed Notes Tool".

Why is this better? With Ubik agents, you can either upload a PDF or search for an open-access paper and save it to your workspace (ingest the document and turn it into an interactive AI doc). With our Cursor-like @ referencing, prompt agents like: What the paper @example is about, highlight 10 points using the notes tool, and summarize why each point is important.

Unlike any available agents or models, Ubik agents can highlight text down to the line level; we call this a note. Every note is referable in chat using the @ symbol or drag-and-drop it into chat with any other file, canvas, found paper, etc.

Cross-analyze, annotate, and generate with citations. Pick from 20+ models, and use @ symbol referencing to craft better prompts that minimize hallucination and increase efficacy.

Start researching: https://app.ubik.studio/chat

Full app for MacOS and Windows soon + Custom EVAL suite almost done and ready to start test (will def share findings)

Hello HN,

I have been an avid user of Linux for a few years and have always wanted to make a contribution to the ecosystem. This is my first standalone contribution.

GNOME Speech2Text is a Shell extension that uses OpenAI’s Whisper automated speech recognition to let you dictate via microphone and have your words transcribed.

Given how much vibe coding I do these days, this extension has made my development with various tools much faster.

I learned a lot building it and got great feedback publishing it in the extensions store.

If you try it, I’d appreciate any critique or suggestions for improvements.