Show stories

KairoSwap is a decentralized exchange (DEX) built on the Ethereum blockchain, allowing users to trade cryptocurrencies and digital assets securely and efficiently without the need for a centralized authority.

Hey HN!

I built Ghostpipe because:

1. I like to keep data about my software in the codebase and under version control.

2. I don’t like always working in raw text files with domain specific languages (eg Terraform, Openapi, er diagrams).

Ghostpipe is an open source tool that creates a bridge between files in your codebase and applications using webrtc. This lets developers work with user interfaces where appropriate, while still having access to the underlying raw text files.

A few side-benefits to this setup are:

1. AI agents are good at working with local text files, so we can keep using those.

2. Generally speaking, no signup or installation is needed to use Ghostpipe apps, because all relevant data is in the codebase.

I built a few demo apps with Ghostpipe support (Excalidraw & Swagger UI), and I hope this proof of concept spurs some interest in taking this idea further.

Thanks!

This is Prompt Canvas - a simple, open-source web app that lets you visually build LLM prompt templates as YAML schemas and then generate complete prompts by populating values in the templates. It’s based on a single HTML file with no real privacy concerns and everything is portable thanks to YAML exports.

Check out the example in the dropdown and read the guide to see how it works: https://promptcanvas.ml4den.com/

LLMs like structure and I found that generating prompts like this is an easy way of giving it to them. It can be useful if you’re doing a degree of prompt engineering and you want to test small variations in your prompts; or if you have a use case where you submit the same promps many times but with some input variations. I found that browsing to a YAML file and tweaking one parameter for a particular job is much cleaner than a web of Notion pages which is what I had before.

Some thought and iteration has gone into the templating engine but everything is still early stage! Some of it is opinionated, and some of it is meant to be quite extensible to different use cases. Let me know if it makes sense.

I built this mostly with Gemini 2.5 Pro out of my own necessity. Would love to know if it's useful for you! Feedback welcome; as are bugs and things on GitHub: https://github.com/ml4den/PromptCanvas

EmoticonHub is a comprehensive website that provides a wide range of emoticons, emoji, and symbols for users to use in their digital communications. The site offers a searchable database of thousands of emoticons and the ability to copy and paste them directly into messages or documents.

Hi HN!I built *pyproc* to let Go services call Python like a local function — *no CGO and no separate microservice*. It runs a pool of Python worker processes and talks over *Unix Domain Sockets* on the same host/pod, so you get low overhead, process isolation, and parallelism beyond the GIL.

*Why this exists*

* Keep your Go service, reuse Python/NumPy/pandas/PyTorch/scikit-learn. * Avoid network hops, service discovery, and ops burden of a separate Python service.

*Quick try (\~5 minutes)*

Go (app):

``` go get github.com/YuminosukeSato/pyproc@latest ```

Python (worker):

``` pip install pyproc-worker ```

Minimal worker (Python):

``` from pyproc_worker import expose, run_worker @expose def predict(req): return {"result": req["value"] * 2} if __name__ == "__main__": run_worker() ```

Call from Go:

``` import ( "context" "fmt" "github.com/YuminosukeSato/pyproc/pkg/pyproc" ) func main() { pool, _ := pyproc.NewPool(pyproc.PoolOptions{ Config: pyproc.PoolConfig{Workers: 4, MaxInFlight: 10}, WorkerConfig: pyproc.WorkerConfig{SocketPath: "/tmp/pyproc.sock", PythonExec: "python3", WorkerScript: "worker.py"}, }, nil) _ = pool.Start(context.Background()) defer pool.Shutdown(context.Background()) var out map[string]any _ = pool.Call(context.Background(), "predict", map[string]any{"value": 42}, &out) fmt.Println(out["result"]) // 84 } ```

*Scope / limits*

* Same-host/pod only (UDS). Linux/macOS supported; Windows named pipes not yet. * Best for request/response payloads ≲ \~100 KB JSON; GPU orchestration and cross-host serving are out of scope.

*Benchmarks (indicative)*

* Local M1, simple JSON: \~*45µs p50* and *\~200k req/s* with 8 workers. Your numbers will vary.

*What’s included*

* Pure Go client (no CGO), Python worker lib, pool, health checks, graceful restarts, and examples.

*Docs & code*

* README, design/ops/security docs, pkg.go.dev: [https://github.com/YuminosukeSato/pyproc](https://github.com/YuminosukeSato/pyproc)

*License*

* Apache-2.0. Current release: v0.2.x.

*Feedback welcome*

* API ergonomics, failure modes under load, and priorities for codecs/transports (e.g., Arrow IPC, gRPC-over-UDS).

---

Source for details: project README and docs. ([github.com][1])

[1]: https://github.com/YuminosukeSato/pyproc "GitHub - YuminosukeSato/pyproc: Call Python from Go without CGO or microservices - Unix domain socket based IPC for ML inference and data processin"

Hey HN! I'm Salim, a content marketer, and I’m working on a website called [quizquestions.org](http://quizquestions.org/). It's my project for building the biggest library of quiz questions.

This is not a quiz website per se, but a library for people who make quizzes.

You see, I make quizzes occasionally. There are many quiz makers, but not many resources for quizzes. And most of the resources are just blogs. So I've wanted to create a more structured website just for this.

Here’s what the site offers at the moment:

- A quiz card: Instead of browsing them, you can get quiz questions in a quiz format - Quiz categories: https://www.quizquestions.org/category - AI question generator: https://www.quizquestions.org/question-generator - A blog page for guides: https://www.quizquestions.org/guides - Saving questions: To use them later for creating a quiz - Sending questions: To send your own questions - Statistics about categories: https://www.quizquestions.org/statistics

This is my first website, so any feedback is welcome!

Hey HN,

I’m Henry, cofounder and CTO at Span (https://span.app/). Today we’re launching AI Code Detector, an AI code detection tool you can try in your browser.

The explosion of AI generated code has created some weird problems for engineering orgs. Tools like Cursor and Copilot are used by virtually every org on the planet – but each codegen tool has its own idiosyncratic way of reporting usage. Some don’t report usage at all.

Our view is that token spend will start competing with payroll spend as AI becomes more deeply ingrained in how we build software, so understanding how to drive proficiency, improve ROI, and allocate resources relating to AI tools will become at least as important as parallel processes on the talent side.

Getting true visibility into AI-generated code is incredibly difficult. And yet it’s the number one thing customers ask us for.

So we built a new approach from the ground up.

Our AI Code Detector is powered by span-detect-1, a state-of-the-art model trained on millions of AI- and human-written code samples. It detects AI-generated code with 95% accuracy, and ties it to specific lines shipped into production. Within the Span platform, it’ll give teams a clear view into AI’s real impact on velocity, quality, and ROI.

It does have some limitations. Most notably, it only works for TypeScript and Python code. We are adding support for more languages: Java, Ruby, and C# are next. Its accuracy is around 95% today, and we’re working on improving that, too.

If you’d like to take it for a spin, you can run a code snippet here (https://code-detector.ai/) and get results in about five seconds. We also have a more narrative-driven microsite (https://www.span.app/detector) that my marketing team says I have to share.

Would love your thoughts, both on the tool itself and your own experiences. I’ll be hanging out in the comments to answer questions, too.

Hey everyone

We’ve just released v0.2.0 of should: a lightweight assertion library for Go with zero dependencies and expressive error messages.

This release brings several new assertions (e.g., BeError, BeWithin, BeSameTime), refactors for better type handling, and improved docs. We’ve also added support for formatted messages and streamlined some core functions based on user feedback.

Repo: https://github.com/Kairum-Labs/should

Feedback and suggestions are very welcome!

Hey HN! This is a fun/educational project I built to learn OS programming. I started working on it right after graduating high school last year and have been working on it on and off during my first year of university. It features a TCP/IP stack, an HTTP server, a RAM file system, a BIOS bootloader, paging and memory management, and concurrent tasks based on cooperative scheduling, along with a custom library. It's written in a C programming style focused on safety (based on a custom library of core abstractions) that's inspired by the writing of Chris Wellons (nullprogram.com).

There is a link to a test deployment in the README. The TCP/IP implementation is nowhere near perfect, of course, so there may be issues loading the page. I'm curious how the system holds up if this post gets any attention ;-)

Hi HN, I'm Oskar, a solo indie Mac developer from Sweden. For those in the Mac community, you might know me from my other apps like Sensei and Trim Enabler.

For years, I've been frustrated by the lack of customisation of macOS. In particular the Lock Screen which supports animated wallpapers, but only ones provided by Apple. There's never been a way to add your own personal videos.

I decided to figure out how to solve this, and the result is Backdrop 2.0. Backdrop is my Live Wallpaper app for Mac, it can play video wallpapers on your desktop. And now it can play on your Lock Screen too.

The core technical challenge, as you can imagine, came from trying to do something that Apple otherwise does not allow. However, through extensive reverse engineering of the macOS wallpaper system, I figured out a way to provide Backdrop wallpapers to the system in a way that allows them to play on the lock screen, and even appear in a custom section in System Settings.

I'm here all day to answer any questions—especially about the reverse engineering process, the challenges of integrating with macOS, or the experience of being an indie Mac developer.

Would love to hear your thoughts and feedback.

I’ve been impressed with Claude Code but one thing that sometimes gets in the way in my workflows is the messy, mangled text that is shown when pasting text from the Claude Code terminal sessions. So I built an open-source utility that cleans extraneous white space, pipes, and other characters from your CC/Codex pastes.

For example, you can turn this:

`How can I create a Claude Code script that │ │ cleans up extraneous characters and cleans up │ │ extra spaces, new lines, and other messiness │

when I copy from Claude Code terminal │ │ prompts or copy code from Claude Responses in │ │ the Claude Code Terminal? It can make it │ │ hard to read, save, and reuse. `

Into this:

`How can I create a Claude Code script that cleans up extraneous characters and cleans up extra spaces, new lines, and other messiness when I copy from Claude Code terminal prompts or copy code from Claude Responses in the Claude Code Terminal? It can make it hard to read, save, and reuse. While this was built with Claude Code in mind it also works on Codex.`

Try it here: https://cleanclode.com

It’s 100% private (no data collection, tracking, completely open-source). If there’s anything you don’t like please just create a GitHub issue, contribute your change (https://github.com/TheJoWo/Clean-Clode), or comment here. Thanks and hope it’s helpful to some of you

Hello everyone!

I’ve been building an Open Source Ecommerce framework for Angular called Daffodil. I think Daffodil is really cool because it allows you to connect to any arbitrary ecommerce platform. I’ve been hacking away at it slowly (for 7 years now) as I’ve had time and it's finally feeling “ready”. I would love feedback from anyone who’s spent any time in ecommerce (especially as a frontend developer).

For those who are not javascript ecosystem devs, here’s a demo of the concept: https://demo.daff.io/

For those who are familiar with Angular, you can just run the following from a new Angular app (use Angular 19, we’re working on support for Angular 20!) to get the exact same result as the demo above:

```bash ng add @daffodil/commerce ```

I’m trying to solve two distinct challenges:

First, I absolutely hate having to learn a new ecommerce platform. We have drivers for printers, mice, keyboards, microphones, and many other physical widgets in the operating system, why not have them for ecommerce software? It’s not that I hate the existing platforms, their UIs or APIs, it's that every platform repeats the same concepts and I always have to learn some new fangled way of doing the same thing. I’ve long desired for these platforms to act more like operating systems on the Web than like custom built software. Ideally, I would like to call them through a standard interface and forget about their existence beyond that.

Second, I’d like to keep it simple to start. I’d like to (on day 1) not have to set up any additional software beyond the core frontend stack (essentially yarn/npm + Angular). All too often, I’m forced to set up docker-compose, Kubernetes, pay for a SaaS, wait for IT at the merchant to get me access, or run a VM somewhere just to build some UI for an ecommerce platform that a company uses. More often than not, I just want to start up a little local http server and start writing.

I currently have support for Magento/MageOS/Adobe Commerce, I have partial support for Shopify and I recently wrote a product driver for Medusa - https://github.com/graycoreio/daffodil/pull/3939.

Finally, if you’re thinking “this isn’t performant, can’t you just do all of this with GraphQl on the server”, you’re exactly correct! That’s where I’d like to get to eventually, but that’s a “yet another tool” barrier to “getting started” that I’d like to be able to allow developers to do without for as long as I can in the development cycle. I’m shooting to eventually ship the same “driver” code that we run in the browser in a GraphQl server once all is said and done with just another driver (albeit much simpler than all the others) that uses the native GraphQl format.

Any suggestions for drivers and platforms are welcome, though I can’t promise I will implement them. :)

Hey all! I recently gave a workshop talk at PyCon Greece 2025 about building production-ready agent systems.

To check the workshop, I put together a demo repo: (I will add the slides too soon in my blog: https://www.petrostechchronicles.com/) https://github.com/Aherontas/Pycon_Greece_2025_Presentation_...

The idea was to show how multiple AI agents can collaborate using FastAPI + Pydantic-AI, with protocols like MCP (Model Context Protocol) and A2A (Agent-to-Agent) for safe communication and orchestration.

Features:

- Multiple agents running in containers

- MCP servers (Brave search, GitHub, filesystem, etc.) as tools

- A2A communication between services

- Minimal UI for experimentation for Tech Trend - repo analysis

I built this repo because most agent frameworks look great in isolated demos, but fall apart when you try to glue agents together into a real application. My goal was to help people experiment with these patterns and move closer to real-world use cases.

It’s not production-grade, but would love feedback, criticism, or war stories from anyone who’s tried building actual multi-agent systems. Big questions:

Do you think agent-to-agent protocols like MCP/A2A will stick?

Or will the future be mostly single powerful LLMs with plugin stacks?

Thanks — excited to hear what the HN crowd thinks!

The article discusses the development of a caffeine tracking app called 'Alyx's Caffeine Tracker', which aims to help users monitor their caffeine intake and avoid overconsumption. The app provides features such as automatic caffeine logging, personalized caffeine limits, and historical data analysis.

ProjectDO is an open-source to-do list application that allows users to manage their tasks and projects. The application features a clean and minimalist design, task prioritization, and integration with various productivity tools.

An install script to create a strong and stable blend of Omarchy on top of CachyOS. You must install CachyOS first (please read the README file.)

Feedback and contributions welcome!

The article introduces semlib, a Python library for semantic similarity and text analysis tasks. It provides a simple, efficient, and easy-to-use interface for working with various text similarity algorithms and can be used for applications such as text classification, recommendation systems, and content analysis.

TL;DR: dagger.js is a buildless, runtime-only micro-framework that plays nicely with native Web Components. It uses HTML-first directives (e.g. +click, +load) so you can ship a page by dropping a single <script> from a CDN—no bundlers, no compile step.

Why I built it Modern stacks are powerful but often heavy: bundlers, compile steps, framework DSLs, local CLIs. For internal tools, small apps, and edge/serverless deployments, I wanted something you can view-source, paste into a page, and ship.

What it is:

Runtime-only: no build or VDOM compile; hydrate behaviors directly on HTML. HTML directives: e.g. +click, lifecycle +load / +loaded / +unload / +unloaded. Zero APIs: dagger.js works in pure declarative mode, modules and directives provide everything you need to build your application. Web-Components-first: works alongside Custom Elements; keep concerns local. Distributed modules: load small, focused script modules via CDN. Progressive enhancement: the page renders without a build step.

Use cases:

Admin panels & dashboards that don’t warrant a full toolchain Embed widgets, docs-sites with interactive bits Edge/serverless apps where cold start and simplicity matter

Links

GitHub: https://github.com/dagger8224/dagger.js Docs/Guide: https://daggerjs.org Examples: https://codepen.io/dagger8224/pens

I’d love feedback on edge-cases, and where it breaks. Happy to answer tough questions here.

The article discusses the Feox Server, an open-source real-time collaboration platform that allows users to share files, communicate, and work together on projects. It highlights the server's features, such as support for multiple file types, real-time updates, and a user-friendly interface.

Hey HN, we’ve been experimenting a lot with MCP servers lately, and one of the most time-consuming challenges has been connecting MCP clients to remote MCP servers. To solve this, we built a library that generates them on the fly, enabling 1-click installation buttons and links for most clients out there.

Feel free to try out the generator and use it to improve the README of your remote MCP server with the generated markdown. You can even configure the library to return HTML instructions if someone accesses your remote MCP server via the web.

Hi HN, I’ve been working on https://datadef.io, a tool to help data team (engineer, architect, project manager) make sense of their data universe.

The problem:

- Data models (dbt, SQL, warehouses) often grow into a tangled mess of tables, joins, and undocumented assumptions. - Lineage is either scattered across tools or missing entirely. - Documentation is usually an afterthought (and gets outdated fast).

Datadef.io aims to fix that by providing:

- Interactive canvas to map tables, relationships, and indicators. - Automatic lineage visualization to trace dependencies. - Metadata management: define table/column-level details, ownership, and KPIs. - AI-generated documentation that stays in sync with your models. - Export/share features so asset managers, analysts, and other teams don’t get lost in spreadsheets or PDFs.

It’s still early, and I’d love feedback from the HN community. In particular:

What’s missing for you in lineage/metadata/documentation tools?

How would you want to integrate a tool like this into your workflow (dbt, Databricks, Power BI, etc.)?

I’d really appreciate your thoughts, feature requests, and criticism.

Thanks!

Hi HN,

I built Small Transfers, a payments platform for SaaS / API makers who want to bill customers per request instead of pushing them into subscriptions or pre-buy packages.

*Why?*

  - Many customers hate subscriptions and/or want to use a service occasionally.
  - Traditional payment processors add a fixed fee to every charge, making charges below 1 USD impractical.
  - Stripe UBB tracks usage, but you still need to write your own auth, add spending limits, and each merchant charges cards separately (extra fees for customers).

  - Each merchant has a Small Transfers account linked to their Stripe account via Stripe Connect, which is used to transfer payouts to merchants.
  - Each customer has a Small Transfers account where we verify them using Google Sign-In, 3-D Secure, and Stripe Radar to minimise the chances of a customer not paying their balance.
  - Customers allow your service to identify and charge them via platform's own OAuth. This also removes the need for your service to implement its own auth. (Simple services don't even need their own database.)
  - Merchants call a simple REST API to authorize and capture a charge with a minimum amount of 0.000001 USD. Note that you can authorize more than you capture, allowing you to authorize the max amount your request might use, and then capture your actual cost plus margin (great for many use cases, e.g., AI).
  - The platform takes care of charging customers and sending payouts to merchants.
  - Merchants pay a flat 3% fee. Customers pay payment processing fees when they pay for their balance.

I've been dog-fooding the platform with my own service (https://unattach.com/) and would love your feedback, specifically:

  - The general approach and whether there is anything I should do differently.
  - Any concerns and how I could mitigate them.
  - Any other feedback.

Thank you for your time! Happy to answer questions here.

We made Ruminate over the past few weeks because we were frustrated with how hard it is to read complex text with LLMs - research papers, novels, long articles, etc.

We found ourselves copy-pasting the text/file into ChatGPT, having chats about different parts of the text in different tabs, and bummed we couldn't easily track the best insights from all those conversations in one place. We wanted one place where we could stay immersed in the text, dip into lengthy and generative rabbitholes when we wanted to (in an unobtrusive way), and have a 'work product' of your learning process (all your notes in one place). No more tab switching - one unified interface centered around the text itself.

With Ruminate, you can: 1) Upload PDFs, EPUBs, or web articles and read them in our custom reader (PDF upload done with https://github.com/datalab-to/marker; headless browser automation for web articles) 2) Highlight text to ask questions, get definitions, or discuss with an LLM (that has context on the whole document, the pages you've read, and will web search too) 3) Save notes, definitions, and annotations (and view them all later in their own tabs)

There are loads of ways to use an LLM to save you time and offload thinking/learning/cognition - we want this to be a tool that actually enables/empowers you to think more deeply and understand more.

Would love your feedback - on the product, the concept, or even your own experiences trying to learn from difficult material (or learn with LLMs broadly). Much appreciated.

Hi HN, Mahmoud here. I'm usually here for Python/FOSS reasons (boltons, glom, CalVer, ZeroVer), and that's still the case, but this time with a twist.

While I was on parental leave from Stripe a couple years back, I started helping my parents figure out their retirement. They're academics coming from overseas, so let's just say I'm a big part of the plan. We found ourselves quibbling over Zoom screenshares, multi-tabbed Google Sheets, and countless links to articles and blog posts. When we looked for professional advice, we found conflicting guidance and misaligned incentives.

I looked at the tools my friends and I use for big decisions and saw a huge gap. This isn't budgeting, nor is this investing. This is actual finance. Money management and decision making. Your options are usually:

1. Read a bunch of Bogleheads, Investopedia, Wikipedia, and Reddit. Then cobble together spreadsheets that we can only hope someone wants to look at (including future you). 2. Hire an expert, which involves a lot of trust, time, and money. You can't shop around too much and you also can't turn back the clock if your advisor burns you. They'll do the spreadsheeting (hopefully correctly) and ignorance is bliss.

I wanted something different. I wanted consumer FP&A, if there were such a thing. A collaborative sandbox for sharing financial context, with a bit of math, plus discussion threads with a context-ful chatbot, and an "explorable explanation" that my parents could use to see how different choices applied directly to them. Google Sheets just wasn't it.

Most importantly it had to solve the trust issue. Most bespoke financial apps are black boxes. I wanted something transparent, verifiable, and forkable. Like open-source software. So, I built FinFam on top of the most broadly-understood low-code platform of all time: the spreadsheet.

FinFam (https://finfam.app) is a platform where you can build and share interactive financial models, powered by XLSX and Google Sheets.

A few examples of questions I've worked through with my early access users:

- https://finfam.app/mahmoud/views/child-cost - How much will it cost you to raise a child from 0 to preschool in the Bay Area?

- https://finfam.app/mahmoud/views/big-tech-vs-startup - Should you take a big tech job or join a startup?

- https://finfam.app/mahmoud/views/ccp-oas-age - When should you start taking your Canadian retirement benefits?

Building each of these models has been super rewarding. The child cost one in particular was a great way to capstone my daughter's 3rd birthday. Yes, I really do have a dataset of her first 2800 diaper changes: https://finfam.app/blog/2025-08-26-baby-cost-view-case-study

Not only has it been more fulfilling and maintainable for me, I'm hopeful that it can open up a new audience of "sheetcoders". There are tons of folks with domain knowledge and spreadsheet know-how, but would never learn (or even vibecode) js/html/react. This way they can build something interactive, without losing the narrative guidance of a good blog post. Get subscribers, find new clients, maybe even get some MRR.

We've been running private alpha all summer. It's still got rough edges, but our small community is getting too much value out of it not to share. Would love to hear what you think. Thanks!

Hi HN,

We just launched Blocks - an AI platform where anyone can build custom work apps and AI agents in minutes, no coding required.

We’re seeing a shift in how software is built and used. With AI, software isn’t just about tracking processes anymore - it can actively help people get work done.

The problem is that most teams still face 2 options: either buy off-the-shelf tools that never quite fit, or invest a lot of time and money into custom development. Neither works well.

Blocks is the third option. It’s an AI-native platform where teams can create apps and AI agents for their workflows just by describing what they need in plain language. The idea is simple: the person who feels the problem should be able to build the solution.

Each app in Blocks has three layers that work together:

UI: customizable interfaces for each role.

AI agents: automate tasks, integrate with systems, and take action.

Data: a built-in database

Having all three in one place means you don’t just get a custom tool - you get a system that automates, adapts, and improves over time. Teams can collaborate internally and externally, set roles and permissions, and connect to the systems they already use.

How it works: you describe what you need in plain language, and Ella (our AI builder) creates the app - UI, agents, and database. From there you can edit, extend, and integrate with tools like Google Sheets, Slack, HubSpot, monday.com and many more. Custom integrations are rolling out soon.

We’d love for you to check it out → https://blocks.diy

It’s still early days, so your feedback would be hugely valuable. We’d really appreciate feedback on:

How clear the build process feels to non-technical users.

Which integrations or agent use cases would be most useful.

Any rough edges you notice while testing.

Thanks for reading! we’re excited to hear your thoughts and happy to answer any questions.

Hi HN!

I’ve always been a fan of application launchers, and I was impressed by the approach the Raycast team took — especially their extension system. About six months ago I started building something similar for Linux, aiming to integrate deeply at the OS level and give extensions a lot of power.

Vicinae is written in C++ with Qt Widgets. I chose Widgets over QML for more imperative control of the UI, especially around extension handling. So far that’s worked well — modern C++ is great.

To support my goals I built a number of custom widgets, including a fully virtualized list that can efficiently render tens of thousands of items. That gave me a lot of respect for Qt — it’s a powerful framework that mostly stayed out of my way.

A key feature is support for Raycast extensions (React + TypeScript), most of which can be installed and used directly inside the launcher (though not all features are implemented yet). There’s also a native API package (@vicinae/api) for writing Vicinae-specific extensions with additional capabilities. This required writing a custom React reconciler — surprisingly straightforward, though still unpolished.

Like Raycast, Vicinae ships with powerful built-in modules, but the goal isn’t to make a clone. I want it to grow into its own project that fits the FOSS model better, while staying compatible with the Raycast ecosystem. I also plan to bring it to other OSes eventually.

I’d love feedback on the technical approach, and suggestions for what would make this useful to you. Contributions are very welcome — I’ve already been pleasantly surprised by how quickly people started helping.

Docs: https://docs.vicinae.com Repo: https://github.com/vicinaehq/vicinae

Hey HN! I've created a terminal interface to browse HN using only the keyboard.

You can expand/hide replies, open external links, browse top, new, ask, show and jobs.

All key bindings and theme colors are customizable :)

It was built with React, OpenTUI, bun and HN API, had a lot of fun building this, excited to hear your feedback!

After two years of development, I'm super excited to release Beat Maker! This is my take on what I hope is the best free, web-based drum machine.

My goal was to build something that was not only fun and easy to use for beginners but also powerful enough for serious producers. I did extensive research on existing drum machines, analyzed their UX, and tried to build something that adds something new.

It's a nearly 100% client-side app, written in ClojureScript, and is a PWA so you can install it to your home screen for an app-like experience.

Besides the standard grid editor, Beat Maker has some unique features that I think HN readers might find interesting:

- Procedural sample generation. One annoying thing about writing beats is searching through folders full of samples. I wanted to improve this and so I added the ability to generate new samples with a single click, giving you an infinite supply of unique drum samples. * Generative beat creation. If you're looking for inspiration, Beat Maker can generate entire patterns for you as a starting point. You can then edit and tweak the beat to your liking. Great for solving the "blank canvas" problem and giving you something good to start from. * Advanced export options. This is where it really shines for producers. You can export your work as: * A standard WAV loop * Individual stems (ZIP) * A MIDI file * A ZIP file of all your samples as WAVs * A SoundFont (.sf2) drum kit from your generated samples * An Impulse Tracker (.it) file for use in trackers like Renoise, OpenMPT or a Polyend * Pocket Operator/Volca sync. It can output a sync signal on the left audio channel to sync with these hardware devices for perfect timing. * Per-Note FX. You can add effects like volume slides, repeats, and start volume changes to individual notes for more complex drum phrases incorporating flam and roll.

As an old school tracker guy, I'm particularly excited about the Impulse Tracker export mode. I was surprised to discover how many DAWs (including hardware like Polyend) can import this format. Of course, you can also pull up Impulse Tracker on DOSBox, or the more modern re-implementation, Schismtracker for that retro experience.

By the way, the beat generator feature is not trained on any artists or anything like that. It's an algorithm I built from scratch myself.

The audio engine is built on a declarative audio graph (using `virtual-audio-graph`), inspired by React's virtual DOM, which makes managing the Web Audio API much cleaner. If you're building web based audio apps I highly recommend checking out this library.

I'd love for you to try it out and let me know what you think. Feedback (and the inevitable bug reports) most welcome! Thank you!

P.S. Also, here's a video summary: https://youtu.be/qVmEn9z3H24

I made a built-from scratch Wayland Compositor to display any GUI app* in the terminal! I think there is a lot of unexplored potential in custom Wayland compositors, a lot of really cool things you can embed existing applications into! So, I started with embedding apps into the terminal because that is the easiest input/output (output is just utf-8 and I use the great `chafa` library for that, and I just read from stdin for the input).

If you have any other ideas for cool Wayland compositors, let me know. I purposedly wrote 80% the app in Typescript to appeal to the most developers and attract cool contributions (I do all drawing with the familiar Canvas2D api, so if there is interest, I can also fork this out into a cool Terminal canvas, let me know!)

I have a blog post here about how I did it, but it’s pretty high level and non technical, so please ask if you have any questions.

[How I Did It](<https://github.com/mmulet/term.everything/blob/main/resource...>)

*technically only Wayland apps and x11 apps with Xwayland. But on Linux that’s mostly everything.