- The first clip-path is a circle (top-left corner) - The second clip-path is a polygon, that acts like a ray (hardcoded, can be improved)
The original work by Iventions Events https://iventions.com/ uses JavaScript, but I found CSS-only approach more fun
Here's a demo and the codebase: https://github.com/Momciloo/fun-with-clip-path
I’m a 75-year-old former fishmonger from Japan, currently working on compensation claims for victims of the Fukushima nuclear disaster. Witnessing social divisions and bureaucratic limitations firsthand, I realized we need a new way for people to express their will without being “disposable.”
To address this, I designed the Virtual Protest Protocol (VPP) ? an open-source framework for large-scale, 2D avatar-based digital demonstrations.
Key Features:
Beyond Yes/No: Adds an "Observe" option for the silent majority
Economic Sustainability: Funds global activism through U.S. commercial operations and avatar creator royalties
AI Moderation: LLMs maintain civil discourse in real-time
Privacy First: Minimal data retention ? only anonymous attributes, no personal IDs after the event
I shared this with the Open Technology Fund (OTF) and received positive feedback. Now, I’m looking for software engineers, designers, and OSS collaborators to help implement this as a robust project. I am not seeking personal gain; my goal is to leave this infrastructure for the next generation.
Links:
GitHub: https://github.com/voice-of-japan/Virtual-Protest-Protocol/b...
Project Site: https://voice-of-japan.net
Technical Notes:
Scalable 2D Rendering: 3?4 static frames per avatar, looped for movement
Cell-Based Grid System: Manages thousands of avatars efficiently, instantiates new cells as participation grows
Low Barrier to Entry: Accessible on low-spec smartphones and low-bandwidth environments
We are looking for collaborators with expertise in:
Backend/Real-Time Architecture: Node.js, Go, etc.
Frontend/Canvas Rendering: Handling thousands of avatars
AI Moderation / LLM Integration
OSS Governance & Project Management
If you’re interested, have technical advice, or want to join the build, please check the GitHub link and reach out. Your feedback and contribution can help make this infrastructure real and sustainable.
What you get: - Full Ubuntu desktop environment in the cloud - Pre-installed AI agent that sees the screen and controls the computer - 24/7 availability - your AI keeps working while you sleep - Uses your own API keys for AI models - Starting at $69/month
The AI can use VS Code, browse the web, run terminal commands, manage files - anything you'd do on a real desktop. I wake up to completed code reviews, finished research reports, and updated documentation.
Built this because setting up an AI agent with a proper working environment was always the painful part. Now it's just one click.
Demo video: https://www.youtube.com/watch?v=wSe4bvDMuKQ
Would love feedback from the HN community!
Hi everyone!
I’m a student developer. Recently, I created Explore Singapore, a RAG-based search engine that scrapes about 20,000 pages of Singaporean government acts and laws.
I recently posted the MVP and received some tough but essential feedback about hallucinations and query depth. I took that feedback, focused on improvements, and just released Version 2.
Here is how I upgraded the system from a basic RAG to a production-grade one.
The Design & UI I aimed to avoid a dull government website.
Design: Heavily inspired by Apple’s minimalist style.
Tech: Custom frontend interacting with a Python backend.
The V2 Engineering Overhaul
The community challenged me on three main points. Here’s how I addressed them:
1. The "Personality" Fix Issue: I use a "Triple Failover" system with three models as backup. When the main model failed, the backups sounded entirely different.
The Solution: I added Dynamic System Instructions. Now, if the backend switches to Model B, it uses a specific prompt designed for Model B’s features, making it mimic the structure and tone of the primary model. The user never notices the change.
2. The "Deep Search" Fix Issue: A simple semantic search for "Starting a business" misses related laws like "Tax" or "Labor" acts.
The Solution: I implemented Multi-Query Retrieval (MQR). An LLM now intercepts your query. It breaks it down into sub-intents (e.g., “Business Registration,” “Corporate Tax,” “Employment Rules”). It searches for all of them at the same time and combines the results.
Result: Much richer, context-aware answers.
3. The "Hallucination" Fix Issue: Garbage In, Garbage Out. If FAISS retrieves a bad document, the LLM produces inaccurate information.
The Solution: I added a Cross-Encoder Re-Ranking layer.
Step 1: FAISS grabs the top 10 results.
Step 2: A specialized Cross-Encoder model evaluates them for relevance.
Step 3: Irrelevant parts are removed before they reach the Chat LLM.
*
The Tech Stack *
Embeddings: BGE-M3 (Running locally)
Vector DB: FAISS
Backend: Python + Custom Triple-Model Failover
Logic: Multi-Query + Re-Ranking (New in V2)
Try it out
I am still learning. I’d love to hear your thoughts on the new logic.
Live Demo: https://adityaprasad-sudo.github.io/Explore-Singapore/
GitHub Repo: https://github.com/adityaprasad-sudo/Explore-Singapore
Feedback, especially on the failover speed, is welcome!
X's current pricing: Basic is $200/month for 10K tweets. Pro is $5,000/month for 1M tweets. Enterprise starts at $42,000/month.
xAPIs.dev pricing: Free tier with 10 calls for testing. Pro at $9.99/month for 10K calls. Lifetime deal at $199.99 one-time for 20K calls/month.
No Twitter Developer account needed. No OAuth setup. Just a simple API key.
47+ endpoints covering: user profiles, followers, tweets, comments, retweets, full-text search, trending topics, Lists, Communities, and Spaces.
Built this for indie devs, researchers, and startups who need Twitter data without enterprise budgets. Free tier requires no credit card.
Happy to answer any questions.
You can now play backgammon with any AI client that supports MCP App (which includes Claude Desktop, VSCode, ChatGPT these days). Actually you can do more than that -- you can play against a friend and have they AI comment; you can watch the AI play itself (boring); you can play against the LLM and have it teach you the finer points of the game (my use case!).
The one problem--and this is a limitation of the current spec--is that the board gets redrawn each time the AI takes a turn. That's actually not that bad, but when the spec adds persistent/reusable views it will be even cooler.
I just launched Fitspire, a small iOS app built around one idea: workouts shouldn’t require 45–60 minutes to be effective.
I’m a builder, and like many people working long hours, I found it hard to stay consistent with traditional fitness routines. Most apps felt either too intense, too time-consuming, or overloaded with features.
So I built Fitspire around:
1. Structured 5-minute workouts 2. Minimal, distraction-free UI 3. Simple progress tracking (streaks, reports, history) 4. No subscriptions at launch (100% free for now)
The goal isn’t to replace full gym training — it’s to reduce the friction of starting.
Tech stack:
1. Built with React Native 2. Backend with Firebase 3. iOS release via App Store
I’m mainly looking for feedback on:
Does 5-minute positioning make sense? What would make this actually sticky? Where do fitness apps usually fail in retention?
Would appreciate any honest feedback — especially critical ones.
Thanks.
Existing tools like fail2ban or CrowdSec felt either too slow to react, too heavy for low resource servers, or painful to tune for modern traffic patterns.
nginx-defender runs inline with NGINX and blocks abusive IPs in real time based on request behavior rather than static rules. It’s designed to be lightweight, simple to deploy, and usable on small VPS setups.
I’ve been running it on my own servers and have seen thousands of abusive requests blocked within hours with minimal overhead.
Would love feedback from people running NGINX in production, especially on detection logic, false positives, or missing use cases.
Putting AI shame aside, it really allowed me to explore so many things in a short amount of time that it feels good, almost enough to compensate the feeling of shame using AI to begin with.
WebGPU isn't in there, although it's in another experimental version, part are indeed written in Rust (game logic).
It has:
- lock delay / grace period (allowing for 15 moves)
- DAS (Delayed Auto Shift) and ARR (Auto Repeat Rate for continuous movement) for horizontal and soft drop movements
- SRS wall kicks (Super Rotation System) to rotate pieces in-place
- Shift+Enter "hidden" level select on the main screen
- Shift+D for debug/performance indicator panel
- Several ranodmizers including 7-bag and NES ones
- combo system with difficulty (time) modes (easy by default) - x2: DOUBLE STRIKE, x5: CHAIN REACTION, x7: MEGA COMBO, x9: PHOSPHOR OVERLOAD, x10+: CRITICAL MASS
- backgrounds which change over time or you can change them with SHIFT+B (B turns it off/on) which react both to music (FFT!) and to your game play when you clear lines
- normal and two phosphor rendering modes of game field (R to toggle)
- CRT Filter (shift+c to toggle)
- F for full screen toggle
- A for previous song, S for pause song, D for next song (all songs made with Suno, of course)
and many more. It was a fun experience for sure, just not sure how to feel about it. On one hand I understand it wouldn't look like it does without my input, and it was a lot of what felt like work (intense sessions looking over the output, correcting etc), yet it doesn't feel like I really made anything by myself. I had fun though.
While at it, created a small demo as well which isn't a game yet: https://www.susmel.com/rolly/ and also something to play with parametric curves here: https://www.susmel.com/graphy/
all within a span of a couple of days while we were having our third baby. The future is weird, and I'm still not sure whether I like it or not. One thing is sure - it's here to stay. Peace out, my friends!
Indian high schooler here, currently prepping for JEE, thought itd be nice to share here.
Three years ago in 9th/10th grade I got a knack for coding, I taught myself and made a custom compiler with LLVM to try to learn C++. So I spent a lot of time learning LLVM from the docs and also C++. It's not some marvelous piece of engineering,
It has:
- Basic types like bool, int, double, float, char etc. with type casting
- Variables, Arrays, Assign operators & Shorthands
- Conditionals (if/else-if/else), Operators (and/or), arithmetics (parenthesis etc)
- Arrays and indexing stuff
- C style Loops (for/while) and break/continue
- Structs and dot accessing
- extern C interop with the "extern" keyword
- Emscripten and WASM, as I also had to make it run on my demo website
- Learning typescript and all for the website (lol)
- Custom parser with basic error reporting and Semantic analysis was a PITA for my undeveloped brain
- Learning LLVM from the docs
- Testing is a very important aspect of making software, I skipped it - big regret
- Learning how computers interpret text
- Programming in general was a new tour for me
- I appreciate unique_ptrs and ownership
Its on my github and there's a link to my web demo (https://vire-lang.web.app/), it might take some time to load the binary from firebase.
Very monolithic, ~7500 lines of code, I’d really appreciate any feedback, criticism, or pointers on how I could’ve done this better.
1) Faster proxying: now it creates several instances of TCP and UDP servers within one process (works on Linux and Android)
2) Better packet parsing: DNS traffic became more detailed and robust
3) Added more optimizations to auto configuration and ability to ignore certain ports
4) License change: migrating from MIT to GPLv3
We managed to do last Sunday's meal plan in under a minute, since all our favorite (100+) recipes are in one place. We also tagged them by daily food themes ( Monday-pasta, Tuesday- meat..). So we can quickly & mindlessly select a meal for each day.
For the app I used AI to classify groceries by aisle, but not generative, since I found that simple ML Models do a better job.
I would love any feedback from other hackers.
Feel free to use it. It's free, apart from syncing, which I had to add a subscription for due to server costs. I tried to make it generous: one subscription per 10 people.
I’m sharing a small open-source desktop tool I built to simplify managing .env files across multiple projects.
Env-shelf scans a selected folder, lists all .env files it finds, and lets you view and edit environment variables from a single UI. The goal is to reduce friction when working on multiple repositories and avoid mistakes caused by manual editing of scattered config files.
It is free and open source.
Demo / landing page: https://env-shelf.vercel.app/
Repository: https://github.com/ivanglpz/env-shelf-local
Feedback and suggestions are welcome.
The results:
MagnaCut: 28:1 positive ratio. The hype is real.
Ginsan: The sleeper favorite. High satisfaction because it almost never chips.
VG-10: Most controversial. High volume, but highest statistical ratio of "micro-chipping" complaints.
How I saved tokens (Inverse Masking): Feeding raw threads into an LLM just to find common terms like "Wüsthof" is a waste of money. I built a hybrid pipeline instead:
Fuzzy Match: Fuse.js catches 80% of common brands for $0.
Mask: Replace those entities with placeholders.
LLM: Feed the "masked" text to the model to catch obscure artisan makers and nuanced sentiment the fuzzy matcher missed.
Stack is Node.js + MongoDB. Full charts and the steel-by-steel breakdown are here: https://new.knife.day/blog/knife-steel-comparisons/all
Would love to hear thoughts on the methodology or if the data misses your favorite steel.
The intersting features are : 1> I used json rag with real time embeddings so that for a few specs and info we don't need to set a whole pipeline..
I have already built " Hierarchical Agentic Rag with Hybrid Search ( knowledge graph + vector search) u can view that on my profile ...
I am actively trying to share as much as possible related to it but that project is actually linked with a huge set of files it's 693k points of data with pgvector+ postgress .. give a visit u will get more idea from that
2> I had tried every sort of whisper models.. faster whisper .. turbo or anything u can u think of ..even with a self c++ engine .. but that model itself was hallucintion prone architecture..
Then I moved to parakeet tdt with silero vad and not parakeet rnn for better speed and optimisations .. repo has further details ..
3> fine tuned a dataset from anthropic rlhf through space and glinner and convert that to a perfect training dataset of the Lama 3.2 3b ..
I will attach the dataset of u need or will upload that to hugging face if u want to use it for yourself..
4> attached phonetic correctors for both output from parakeet and llama for better tts working .
5> I used setfit to route the queries and confidence based semantic search for faster and accurate as much as possible
6> I am using sherpa onxx and qued the tts and stt and everything but as a experimentation I have also achieved llama generating respond and kokora processing as a batch with a full nyc working as well and everything on my laptop...
7> along with these my frontend also relies on heavy three.js and 3d view files but I had applied optimisations there which works perfectly with everything together on the laptop..
8> I also applied glued interaction to the llm model .. implemented FIFO with 5 interactions and storing them for future fine tuning and phonetic words additions.
Pls give a visit it and let me know if I should learn something new ..
One kind note : as a enthusiast spending so much energy on these things things .. I have taken help from ai for the md files and expansion or explanations in the codes for better help of every single person...
Would love feedback, especially on the palette quality and if the styles actually feel distinct from each other.
It runs notebooks in isolated pods and can validate them against deployed ML models on platforms like KServe, OpenShift AI, and vLLM. It also does regression testing by comparing notebook outputs against a "golden" version.
The goal is to make notebooks more reliable and reproducible in production environments. It's built with Go and the Operator SDK.
We're looking for contributors. There are opportunities to work on features like smarter error reporting, observability dashboards, and adding support for more platforms.
GitHub: https://github.com/tosin2013/jupyter-notebook-validator-oper...
Examples
Simple local usage:
ollama pull llama3.1:70b ollama pull llama3.1:8b
python3 cli.py exec \ --orchestrator ollama:llama3.1:70b \ --worker ollama:llama3.1:8b \ --task "Summarize 10 news articles"
This runs a planner + worker flow fully locally.
Hybrid cloud + local usage:
export ANTHROPIC_API_KEY="sk-ant‑..." ollama pull llama3.1:8b
python3 cli.py exec \ --orchestrator anthropic:claude-3-7-sonnet-20250219 \ --worker ollama:llama3.1:8b \ --task "Compare 5 products"
export ANTHROPIC_API_KEY="sk-ant‑..." ollama pull llama3.1:8b
python3 cli.py exec \ --orchestrator anthropic:claude-3-7-sonnet-20250219 \ --worker ollama:llama3.1:8b \ --task "Compare 5 products"
Routes tasks between cloud provider models and a local worker.
TUI chat mode:
python3 cli.py chat \ --orchestrator anthropic:claude-3 \ --worker ollama:llama3.1:8b
Interactive CLI chat with live logs and cost breakdown.
Why it matters • Orchestrate multiple LLMs — OpenAI, Anthropic, Ollama/llama.cpp — without writing custom routing logic. • Smart routing and fallback — choose better models for each task and fall back heuristically or learned over time. • Cost tracking & session logs — see costs per run and preserve history locally. • Optional scraping + caching — enrich tasks with real web data if needed. • Optional MCP server integration — serve llm‑use workflows via PolyMCP.
llm‑use makes it easier to build robust, multi‑model LLM systems without being tied to a single API or manual orchestration.
It includes: - A virtual filesystem with POSIX-compatible API - 40+ shimmed Node.js modules (fs, path, http, crypto, stream, etc.) - A package manager that installs real npm packages client-side - Built-in Next.js (App Router) and Vite dev servers with HMR - Service worker bridge that makes virtual servers accessible via real URLs
The main use cases are interactive code playgrounds, live documentation, and AI coding agents that need to execute code client-side without provisioning a sandbox server.
It's not a WebContainers replacement, no real TCP/IP or native modules. Think of it as the lightweight alternative when you just need a demo or playground running from a static HTML page.
It's experimental and definitely has bugs. Would love feedback, especially on the module shims and framework support.
It also supports looking up the latest versions of almost 1000 tools, such as development runtimes like Python, Node, dotnet, development tools like Gradle, and various DevOps tools like kubectl or Terraform, via the mise-en-place tool.
Supported ecosystems/tools:
1) Developer ecosystems: NPM, PyPI, NuGet, Maven/Gradle, Go, PHP, Ruby, Rust, Swift, Dart
2) DevOps ecosystems:
- Docker: Docker container images from Docker registries
- Helm: Helm charts from ChartMuseum repositories and OCI registries
- GitHub Actions: Actions hosted on GitHub.com, returning their current version, their inputs and outputs, and (optionally) their entire README with usage examples
- Terraform Providers and Modules: Providers & Modules from Terraform Registry, OpenTofu Registry, or custom registries
- Various tools such as kubectl, terraform, gradle, maven, etc. (as long as they are supported by mise-en-place)
There is a free-for-all hosted version on https://package-version-check-mcp.onrender.com/mcp, and you can run it with Docker or uv (uvx).
This MCP is certainly not the first one to tackle the "outdated dependency" problem. However, I feel that it has various advantages over other MCPs:
- It offers (far) better ecosystem coverage than other MCPs
- There is full test coverage, with automated dependency updates (powered by Renovate) and regular, automated release builds. In contrast, other projects are often vibe-coded, have poor (or no) tests, and are already abandoned
- This MCP uses a minimal Docker/OCI image, hardened for security. SBOMs you generate with tools like Trivy are known to be correct, and the image is signed with Cosign (which allows you to verify its authenticity in case you want to self-host the MCP)
Let me know what you think.