GitHub: https://github.com/m31coding/fuzzy-search Live demo: https://www.m31coding.com/fuzzy-search-demo.html
I would love to hear your feedback and any suggestions you may have for improving the library.
Happy coding!
I'm happy to announce we've finally released our 2nd macOS app, Draw Over It, a tiny desktop app that enables drawing, highlighting, or annotating directly on top of anything on your Mac.
I've always wanted something like this for instant and unobtrusive sketching and annotation for pair programming and demos. I always found the standard web-based diagram and drawing tools a bit too cumbersome. So we built a simple overlay that could appear over any window or app with one shortcut.
It doesn't collect any user data and doesn't require any system permissions - it's sandboxed. It all stays on your device. You can export your annotations to a PNG with one click - or just take a screenshot if you need the background too.
It offers a slim but functional toolkit for every day tasks:
- Global hotkeys, hit a shortcut and start drawing over any app
- Multiple tools, pens, shapes, highlighters
- Per-screen canvases, each monitor gets its own space
- Focus mode, temporarily blur the background to emphasize what matters
- Low footprint, no subscriptions, no sign-ups, no data collected
- Localization, the app is translated to 14 languages
These two reasons make it different from other canvas apps, it's simple, lean and keeps your data on-device only.
It’s a one-time purchase ($2.99) on the Mac App Store.
I’d love feedback and suggestions for improvements!
Here's what it looks like:
import sqlite3
conn = sqlite3.connect(":memory:")
conn.load_extension("./libgraph.so")
conn.execute("CREATE VIRTUAL TABLE graph USING graph()")
# Create a social network
conn.execute("""SELECT cypher_execute('
CREATE (alice:Person {name: "Alice", age: 30}),
(bob:Person {name: "Bob", age: 25}),
(alice)-[:KNOWS {since: 2020}]->(bob)
')""")
# Query the graph with relationship patterns
conn.execute("""SELECT cypher_execute('
MATCH (a:Person)-[r:KNOWS]->(b:Person)
WHERE a.age > 25
RETURN a, r, b
')""")
What works now: - Full CREATE: nodes, relationships, properties, chained patterns (70/70 openCypher TCK tests) - MATCH with relationship patterns: (a)-[r:TYPE]->(b) with label and type filtering - WHERE clause: property comparisons on nodes (=, >, <, >=, <=, <>) - RETURN: basic projection with JSON serialization - Virtual table integration for mixing SQL and Cypher
Performance: - 340K nodes/sec inserts (consistent to 1M nodes) - 390K edges/sec for relationships - 180K nodes/sec scans with WHERE filtering
Current limitations (alpha): - Only forward relationships (no `<-[r]-` or bidirectional `-[r]-`) - No relationship property filtering in WHERE (e.g., `WHERE r.weight > 5`) - No variable-length paths yet (e.g., `[r*1..3]`) - No aggregations, ORDER BY, property projection in RETURN - Must use double quotes for strings: {name: "Alice"} not {name: 'Alice'}
This is alpha - API may change. But core graph query patterns work! The execution pipeline handles CREATE/MATCH/WHERE/RETURN end-to-end.
Next up: bidirectional relationships, property projection, aggregations. Roadmap targets full Cypher support by Q1 2026.
Built as part of Agentflare AI, but it's standalone and MIT licensed. Would love feedback on what to prioritize.
GitHub: https://github.com/agentflare-ai/sqlite-graph
Happy to answer questions about the implementation!
Some background: OHTTP is a protocol that hides who you are from the data you send - if you've ever used products of Apple, Mozilla, Fastly, or Cloudflare (to name a few) you probably used OHTTP.
Key Features:
- implemented as http.RoundTripper
- supports chunked transfer encoding
- customizable HPKE (e.g., for custom hardware-based encryption)
- built on top of twoway and bhttp libraries
Repo: https://github.com/confidentsecurity/ohttp
Detail: https://blog.confident.security/ohttp/
Explainer: https://support.mozilla.org/en-US/kb/ohttp-explained
Specs: https://datatracker.ietf.org/doc/rfc9458/ , https://datatracker.ietf.org/doc/draft-ietf-ohai-chunked-oht...
Feedback welcome!
Tiled Words merges tile-placing board game mechanics with crosswords. You rotate and rearrange tiles to find clues and rebuild a broken crossword. Every day there's a new themed puzzle for you to solve.
The game is web based: the graphics are SVGs, animations are powered by CSS, and Vue/Nuxt are used to power templating, reactivity, and routing. Most of the complex logic lives in TypeScript modules. The whole thing is responsive.
It's been a long time in the making. I started the first version in the Summer of 2024. The game was originally inspired by board games like Patchwork. I wanted to make a digital game where you placed tiles on a board. I explored layering a few different game mechanics on top of that but none of my prototypes felt fun to play, so I shelved the idea around September 2024. (At its most complex, I was developing a deck-building game about planting flowers to heal a broken land.)
This July while on a hike with my wife I had an idea: what if I put letters on the tiles and let you rotate and place them to build words. I whipped up a prototype and actually enjoyed playing it. Even better, my friends thought it was fun too. I was convinced to keep going when I shared it online and got a lot of positive feedback from strangers.
Since launch I've had several hundred people visit the site every day, and around ~350 people finish the daily puzzle every day. I've gotten a lot of sugI'm hoping to share this with a larger audience since people seem to enjoy it.
It's been a lot of fun to design and develop. I enjoy working with my wife to build new puzzles. (She's better at thinking of the clues than I am!) Please share it with your friends and check back tomorrow for a new puzzle!
(I hope it's okay that I'm sharing this again. Last time I tried, it didn't get much engagement but the people who did comment seemed interested.)
This is a KiCad plugin with a few different algorithms, the coolest of which is a 'Manhattan routing grid' autorouter that routes along orthogonal traces. The basic idea was to steal an algorithm from FPGA routing and apply it to PCBs. I'm using CuPy for speeding up the routing; CPU-bound is at least 10x slower than the GPU version.
This is in a very pre-alpha state, but it does _technically_ work. It's not great by any measure but then again it is an autorouter.
I have a writeup with the how and why it was made: https://bbenchoff.github.io/pages/OrthoRoute.html
And a video showing it route a 512-net backplane in just over 2 minutes: https://www.youtube.com/watch?v=KXxxNQPTagA
This is very cool and one of the first good uses of the KiCad IPC API that was released a few months ago. If this sounds interesting and useful, PRs and issues welcome.
That was possible because of the great community that evolved around this leafy project, that kept me motivated as well as supported me in a very kind and lovely way.
After a few months of no new version release, a few days ago I've published v5.3 of HortusFox, which provides some cool changes to help empower your plant parenting. You can see a very detailed changelog in the 5.3 release page on GitHub. Overall 25 issues have been resolved, where some of them were actually quite big.
If you're new to HortusFox: the system offers you a large number of features to support your plant parenting (or gardening) journey with plant details, locations, photos, default and custom plant attributes, inventory system, tasks system, calendar, history (to keep a memory of your leafy friends), collaborative group chat and a few opt-in features such as weather forecast or plant identification (via photo). It also offers an extensive REST API, backup feature and themes (if you want your workspace a little more personal).
I have to say, for me it's the perfect blend of two things: The passion for software development as well as the fondness for nature. I'm really grateful for that.
Thanks for reading and have a wonderful and leafy day.
The core idea: Most animation libraries work in milliseconds. Music works in beats. This creates a mismatch - hardcode a bounce for 500ms (perfect at 120 BPM), switch to 90 BPM, and everything drifts because 500ms is now 0.75 beats.
Emotive Engine uses musical time as the atomic unit. Specify animations in beats, and they automatically become: - 500ms at 120 BPM - 667ms at 90 BPM - 353ms at 170 BPM
Change tempo, everything adjusts. No recalculation needed.
Built for AI interfaces (chatbots, voice assistants) but works for any real-time character animation. Pure Canvas 2D, 60 FPS on mobile, 2,532 tests passing.
Live demo at https://emotiveengine.com/demo - the hero banner on GitHub was generated with the engine itself.
Happy to answer any technical questions! MIT licensed.
I’ve been building SaaS products and running small service businesses for a while, and I kept running into the same issue — founders with great small ideas (like an internal dashboard, automation, or MVP) struggle to get them built quickly without overpaying or managing freelancers.
Agencies quote $5k–$10k, freelancers are hit-or-miss, and even with no-code tools, you still need design and tech skills.
So I built MicroBuilder.dev - a simple way for non-technical founders and small teams to get small builds done.
Here’s how it works: 1. You describe what you want built or your pain. 2. An AI system gives an instant price estimate 3. We match you with a vetted builder who delivers within a few days
Focusing mainly on small, fixed-price builds – Mini SaaS apps – Dashboards or client portals – Automations (n8n, Make, Zapier, etc.)
Each project includes 30 days of free bug-fix support and full code ownership.
I’d love feedback from this community — especially on: – Pricing and tier structure – How to make it more transparent or self-serve – Whether this fills a real gap between agencies and no-code tools
This is an early-stage experiment; I’m validating demand this week.
Appreciate any thoughts or critique
David
Since we launched our core document parsing API, we've had fantastic feedback from developers who love the precision and the "pay-on-accept" model. But as we watched people build more complex systems, we noticed a common pattern: everyone was writing the same boilerplate code to manage their workflows.
Developers were building their own logic to handle workspaces, manage batches of files within tasks, poll for results, and handle state. Our raw API is powerful for single transactions, but it left the orchestration part up to you.
To solve this, we've built and are now launching our MCP (Multi-Channel Platform) server.
Think of it as a stateful, command-based orchestration layer that sits on top of our core parsing API. Instead of you having to write code to manage IDs and track the status of multi-file jobs, the MCP server handles it for you through a simple, logical interface.
The workflow is structured around a clear hierarchy: Workspace -> Task -> File.
You can use straightforward commands like: - UnDatasIO_get_workspaces to get your work_id. - UnDatasIO_upload to add files to a specific task_id. - UnDatasIO_parse to kick off parsing for a list of file_ids. - UnDatasIO_get_parse_result to poll for the job status without building your own loop.
This is perfect for anyone building complex, multi-file data processing pipelines, integrating with low-code platforms, or who simply wants to manage large batch jobs without the hassle of writing and maintaining state-management code. Our goal is to let you focus on what to do with the data, not the plumbing required to get it.
We believe this will make building robust document workflows much faster and more reliable. We're just getting started and are eager for your feedback. We've put together a comprehensive guide and a video tutorial to walk you through it.
MCP User Guide (Full API Reference): https://docs.undatas.io/mcp/undatas-mcp/
Video Tutorial on YouTube: https://www.youtube.com/watch?v=_xobbKiPyf4
Our Official Website: https://undatas.io/
I'll be here all day to answer any questions. Let us know what you think
We are used to having imports at the beginning of every file, but it might be better to keep them all in one place for the entire crate. This way code can be moved freely between files, and smaller files are encouraged. To open a file and immediately see useful code is also refreshing.
It is highly beneficial when braces always mean closure. A strong argument for the indent-based code structure.
Object tree creation looks more natural without parentheses and commas for function invocation.
Sequential code enforcement, when elements can only depend on what is defined above, opens new possibilities. One is splitting the type constructor among multiple files, potentially located in different crates. An example of how this is useful. One crate contains UI control definitions with layout code, while additional crates extend control types with data and calculations, necessary for their rendering, resulting in multiple switchable backends, like Vulkan or Skia. Maintaining such data outside complicates the code.
There is a tendency to move away from type hierarchies. I think it is better to tune them down and reevaluate. A major source of complexity is the ability to override existing implementation of a method, because a code is being added to a type without a guarantee on whether it is going to stay. Such a guarantee will make hierarchies worth keeping more often.
qwe has always focused on file-level version control system, tracking changes to individual files with precision. With this new release, the power of group tracking has been added while maintaining our core design philosophy.
qwe allows you to bundle related files into a single, named snapshot for easy tracking and rollback.
Group Creation: Create a logical group (e.g., "Project X Assets," "Configuration Files") that contains multiple individual files.
Unified Tracking: When you take a snapshot of the group, qwe captures the current state of all files within it. This makes rolling back a set of related changes incredibly simple.
The Flexibility You Need: Individual vs. Group Tracking:
A key design choice in qwe is the persistence of file-level tracking, even within a group. This gives you unparalleled flexibility. Example: Imagine you are tracking files A, B, and C in a group called "Feature-A." You still have the freedom to commit an independent revision for file A alone without affecting the group's snapshot history for B and C. This means you can: - Maintain a clean, unified history for all files in the group (the Group Snapshot). - Still perform granular, single-file rollbacks or commits outside the group's scope.
This approach ensures that qwe remains the flexible, non-intrusive file revision system that you can rely on.
Features:
- Runs entirely on your machine (privacy-first) - Supports local whisper models - Openai api integration optional - Free and open source
Technical notes:
- Macos only (haven't tested on windows) - Built with Rust, ffmpeg 8, Electron - You'll need to either run from source or allow the app in system settings (no apple developer cert, so gatekeeper will complain). Pretty straightforward if you're comfortable with terminal or adjusting security settings
Figured the HN community might find it useful or have suggestions for improvement.
Github: https://github.com/riseandignite/capslap
Happy to answer questions or take feedback.
Believe it or not, it's still super common for research / data-analysis teams to handoff work to Engineering because they aren't able to easily scale analyses on their own. Engineering managers we spoke with frequently attempt to onboard these teams to tools like Apache Airflow, Prefect, Dask, or Ray, but these tools come with hidden tradeoffs and complexity that researchers often struggle with on their own. This is can be very painful for engineering managers who wind up acting like highly paid support/education staff, instead of focusing their real work. It's also very painful for research teams who are often blocked waiting on engineering/devops to help them.
This is why we created Burla, it's designed to be simple enough for even complete beginners to scale python across thousands of VM's. It's open-source, works with GPU's, custom containers, and up to 10,000 CPU's in a single cluster.
If you want to give it a try signup here: https://burla.dev/signup, and we'll send you a personalized instance with some free compute today!
