I built World’s Backlog (https://worldsbacklog.com ) to collect real problems directly from people working inside different industries.
Contributors post workflow pain, others validate it, and builders can study severity, frequency, and willingness to pay before building anything.
Would love feedback from builders and people who feel real pain at work.
https://github.com/jamierpond/yapi
Still very early, but it makes me much more productive vs Postman, Bruno, Insomnia, etc.
If youre a nvim/tmux culture human, you might like this!
I wondered why they don't use SVG (since the original source in the PDF is usually a vector diagram), and when I went to try to extract diagrams as SVG from a PDF, I wasn't able to find an easy way to do that, even when trying SVG editors which have support for importing PDFs such as Inkscape.
So I built a small GUI tool which lets you open a PDF and view it, visually select a rectangular region (which you can drag to reposition), and save the region to an SVG.
It uses the Poppler CLI tools to do the PDF rendering and extraction, but it would be difficult to specify the necessary flags (especially the coordinates) to these tools manually without a GUI tool like this.
Please try it out and see if it's helpful! Feature requests and bug reports are welcome, including any issues with installation or usage.
Thanks for taking a look.
We built this because we were dissatisfied with the current build caching options available for Rust. Buck and Bazel require learning a new tool. GitHub Actions and swatinem are too coarse-grained (either the whole cache hits, or none of it does) and finicky to debug, and cargo-chef and Docker layer caching have the same problems.
We wanted something that could restore cache at the package level, did not require integration-specific setup, and worked everywhere.
Hurry is fully open source under Apache 2. You can try it out now with our cloud hosted caching service at https://hurry.build or self-host your own build cache service from https://github.com/attunehq/hurry. Sorry in advance for the rough edges - we have some customers already exercising the hot paths, but build tools are pretty large surfaces. We’ve got a list of known limitations at https://github.com/attunehq/hurry?tab=readme-ov-file#known-l....
We’d love for folks here to try it out (maybe on your next Rust winter side project?) and let us know what you think. We’ll be in the comments here, or you can email us at [email protected].
Our goal is to make all parts of software engineering faster. If you have some part of your coding workflow that you want faster, please feel free to reach out. We’d love to chat.
I didn't want to extend the library itself, so I built tinydocx: <1K lines of TypeScript, zero dependencies, 7.7KB minified+gzipped. The popular docx package is 108KB with 5 dependencies.
What's included: - Text formatting (bold/italic/underline/strikethrough, colors, custom fonts) - Headings (H1-H6) - Tables with borders and column widths - Bullet and numbered lists (with nesting) - Images (PNG, JPEG, GIF, WebP) - Hyperlinks - Headers/footers with page numbers - Blockquotes and code blocks - Markdown to DOCX conversion - ODT (OpenDocument) support with the same API
What's not included: - Table of contents, footnotes, bookmarks - Track changes, comments - Multi-column layouts, text wrapping - Reading/modifying existing .docx files - Math equations, drawing shapes
DOCX files are just ZIP archives containing XML. Once you understand the structure, generating simple documents is straightforward. The hard part is knowing which XML elements Word actually requires vs. what's optional cruft.
Works great for invoices, reports, form letters - anything where you want the recipient to edit the document. Pairs nicely with tinypdf when you need both formats.
GitHub: https://github.com/Lulzx/tinydocx npm: npm install tinydocx
## Coderive - Iterating Through 1 Quintillion in a Loop
*Subtitle: How a phone interpreter achieves what supercomputers cannot*
The Impossible Loop:
```java // In any other language, this would be computational suicide for i in [0 to 1Qi] { // 1,000,000,000,000,000,000 iterations arr[i] = i * i } ```
Traditional Reality:
· Python: MemoryError at array creation · Java/C++: Theoretical 31 years (with 8 exabytes of RAM) · NumPy/TensorFlow: Immediate crash · GPU Computing: 80GB VRAM limit exceeded
Coderive's Reality: 50 milliseconds.
The Magic Behind It:
1. NaturalArray: Virtual arrays that store formulas, not data 2. Runtime Pattern Detection: Transforms loops to mathematical expressions 3. Lazy Evaluation: Computes only what's accessed 4. Formula Storage: LoopFormula, ConditionalFormula, MultiBranchFormula
Technical Deep Dive:
```java // What you write: for i in [0 to 1Qi] { if i % 2 == 0 { arr[i] = i * i } elif i % 3 == 0 { arr[i] = i * i * i } else { arr[i] = i } }
// What Coderive creates internally: arr.addMultiBranchFormula( conditions: [i%2==0, i%3==0], expressions: [ii, iii], elseExpr: i, range: [0, 1Qi] ) ```
The Optimization Pipeline:
``` User Code → Pattern Detection → Formula Creation → Lazy Evaluation ↓ ↓ ↓ ↓ O(n) O(1) O(1) O(1) per access ```
Complete Pattern Coverage:
· Simple Transformations: arr[i] = f(i) → LoopFormula · Binary Decisions: if-else → ConditionalFormula · Multi-way Branches: if-elif-else → MultiBranchFormula · Partial Updates: if-only with implicit else preservation
Real-World Impact:
```java // Process every pixel in 8K video (≈33 million frames) for frame in [0 to 33M] { for pixel in [0 to 76804320] { // 33 million frames × 33 million pixels if brightness > 128 { pixels[pixel] = 255 } elif brightness > 64 { pixels[pixel] = 128 } else { pixels[pixel] = 0 } } } // Traditional: Impossible // Coderive: Seconds, not centuries ```
The Secret Sauce:
· No data movement (arrays stay virtual) · No parallel programming (formulas are inherently parallel) · No memory management (O(1) memory complexity) · No specialized hardware (runs on Java 7)
Conclusion: Coderive doesn't just make loops faster—it redefines what's computationally possible on commodity hardware.
Check Coderive now at: [https://github.com/DanexCodr/Coderive](https://github.com/DanexCodr/Coderive)
Friend went through a nasty divorce. Had $750k going into the marriage (inheritance), put it in a joint account like an idiot. Five years later, account's been up and down, money mixed with paychecks and mortgage payments. Lawyer says "you need a forensic accountant to trace what's still yours." Quote comes back: $5k, 4 weeks minimum.
I'm sitting there thinking - this is just transaction categorization and some relatively simple math (the "Lowest Intermediate Balance Rule" if you want to google it). Why doesn't software exist for this?
Turns out it kind of doesn't. There are $50k enterprise tools for big law firms, but nothing a normal person or small practice can actually use.
So I built a Django app that takes bank statement PDFs, uses latest Mistral's OCR-3 to parse them (because real-world bank PDFs and shots are a nightmare - scanned, rotated, weird formats), then runs them through an LLM to categorize transactions and a Python implementation of the LIBR algorithm.
Output is a court-usable report showing exactly how much of your "separate property" is still traceable, with visualizations and evidence logging (SHA-256 hashing for chain of custody, audit trails, the works).
Its FREE and whole process takes about 3 minutes. I'm in India and honestly just want to see if people use it.
What's really interesting:
-Latest Mistral's document OCR-3 is genuinely impressive on messy banking PDFs. Tried Tesseract first, got maybe 60% accuracy.
-The LIBR algorithm is conceptually simple but has some gnarly edge cases (what happens when account hits zero? how do you handle multiple deposits of separate property? etc.)
-Evidence integrity was harder than expected. Lawyers care a LOT about proving a document hasn't been tampered with.
-Used Celery because some statements have 10k+ transactions and you can't block the request
Currently running on Render with Postgres. Code's not open source yet because honestly it's kind of a mess and I need to clean up some stuff, but might do that if there's interest.
Things I'm unsure about:
-Should it be free? Subscription? How much? Bring your won key? Cause I'm putting money out of my pocket.
-B2C vs B2B - individuals might use this once, but lawyers could use it repeatedly.
-How much do I need to worry about legal liability for the output? I have disclaimers everywhere but still
Anyway, it's live: https://exitprotocols.com.
Would love feedback, especially if you've dealt with this problem before or know the family law space.
Laziness is the goal, this is for fun, not business or personal development.
I used it to make “Pac Man With Guns”
Taking a break from all discourse on AI and its place in professional coding, it’s really fun to play and prototype games with it. I have limited time and focus, and it’s cool to take half and idea and get a workable thing
from pctx_sandbox import sandbox
@sandbox(dependencies=["requests"]) def fetch_url(url: str) -> str: import requests return requests.get(url).text
result = fetch_url("https://example.com") # runs in container
Technical details:
- Uses rootless Podman for container isolation (all the Linux namespace stuff: PID, mount, network, user) - Maintains a warm pool of workers per dependency set, so there's no cold-start penalty after the first call - Dependencies are cached and installed once per unique combination - Resource limits enforced via cgroups
The security model is "defense in depth" – it's container isolation, not a VM, so it's not a perfect security boundary. But it's good enough that I'm comfortable letting Claude use it on my machine.
Would love feedback. Thanks!
Training AI Models to reason is currently very expensive. You require a lot of data, tons of compute in Reinforcement Learning, and more. And the reasoning infrastructure is not reusable.
On top of all this, we don't really have a way to improve targeted performance and personalize intelligence within the systems.
Over the last year, I've been looking into latent space reasoning as a way to solve this. By doing this, we can create a different reasoning layer that is reusable across models. We created a simple layer for 50 cents, and it already improves performance. We're working with a few people across major AI Labs at exploring this, but I also wanted to open source because intelligence deserves to be open. To that end, our startup has even opened up a small monthly prize pool for top contributors to the repo.
Would love to have you in there. Here is a report we did breaking down the core design philosophy here-- https://www.artificialintelligencemadesimple.com/p/how-to-te...
There's over 23M embeddings (2048*32 bit Voyage-3.5-Lite over ~300 token chunks, 20% overlapped), 600 GB of indexes for performance, a prompt for letting Claude Code w/ Opus 4.5 drive usage, and there's full support for vector algebra. One can actually embed arbitrary concepts like "FTX" and "guilt" vectors and store these embeddings on the server, and refer to them in queries like @FTX + @guilt.
Because you and your agent can write and run 100k character SELECT statements for up to 60s, you can really answer some incredibly nuanced questions very easily now.
I'm doing a startup building subjective judgement infrastructure, HMU if interested in angel investment.
I built Skyler (https://github.com/05sanjaykumar/Skyler-AI), an AI-powered email organizer focused on privacy and semantic search. It was live at skylerinbox.com for a few months before I shut it down due to Google's CASA compliance requirements (100-user OAuth limit without expensive third-party certification).
Built in 42 days solo as a 3rd-year CS student in India.
Tech stack: - Frontend: Next.js, NextAuth, Tailwind, shadcn/ui - Backend: Express (TypeScript), Prisma, Supabase - AI/ML: distilbert (sentiment), all-MiniLM-L6-v2 (semantic search), Groq Llama for summarization - Infrastructure: Docker, Nginx, Hetzner VPS - Privacy-first: Client-side caching with Dexie, minimal server storage
Key challenges: - Gmail OAuth token refresh issues and rate limiting - CASA compliance wall at 100 users (would cost thousands for certification) - Building privacy-first architecture (harder than standard SaaS) - Payment integration (PayPal + Cashfree for India)
Why I shut it down: The compliance overhead (CASA certification, legal costs, ongoing OAuth verification) didn't make sense for a solo MVP. The infrastructure worked great, but the business constraints were brutal.
Demo video: https://youtu.be/ATNYoNt6oBE
All code is open source as a learning resource. Happy to answer questions about the technical decisions or compliance issues I hit!
We built Haystack Slop Detector to scan PRs and flag changes that look like they were made without reviewing them first. We support AI use, but we think it’s important to surface a lack of polish before it becomes a maintainer’s problem.
We'd love feedback, especially from maintainers and people building agentic workflows!
It streams live dispatch data from SF's official open data portal, uses an LLM to translate police codes into readable summaries, and auto-redacts sensitive locations (shelters, hospitals, etc.).
Built it at a hack night after getting annoyed that Citizen is the only real-time option and they paywall it.
Repo: https://github.com/midaz/sf-police-blotter Discord: https://discord.gg/KCkKeKRm
Happy to discuss the technical approach or take feedback.
I’m a solo founder and SRE background engineer. I built CleanCloud to solve a problem I kept seeing on teams I worked with: cloud accounts slowly filling up with orphaned, unowned, or inactive resources created by elastic systems and IaC — but nobody wants tools that auto-delete things.
CleanCloud is a small, open-source CLI that: - Scans AWS and Azure accounts in read-only mode - Identifies potential “hygiene” issues (unattached EBS volumes, old snapshots, inactive CloudWatch logs, untagged storage, unused Azure public IPs, etc.) - Uses conservative signals and confidence levels (HIGH / MEDIUM / LOW) - Never deletes or modifies resources - Is designed for review-only workflows (SRE-friendly, IaC-aware)
What it intentionally does NOT do: - No auto-remediation - No cost optimization / FinOps dashboards - No agents, no SaaS, no ML - No recommendations based on a single risky signal
This is early-stage and I’m explicitly looking for feedback from SREs / DevOps folks: - Are these the right problems to focus on? - Are the signals conservative enough to be trusted? - What rules would you actually want next?
Repo (MIT licensed): https://github.com/sureshcsdp/cleancloud
If this looks useful, a helps a lot. Brutally honest feedback welcome.
Many Thanks Suresh
Meds is a user-space firewall for Linux that uses NFQUEUE to inspect and filter traffic. In the latest v0.7.0 release, I’ve added ASN-based filtering using the Spamhaus DROP list (with IP-to-ASN mapping via IPLocate.io).
Key highlights: Zero-lock core, ASN Filtering, Optimized Rate Limiting, TLS Inspection, Built-in Prometheus metrics and Swagger API.
Any feedback is very welcome!
I built LLMKit after getting frustrated with choosing the right LLM for different projects. Instead of guessing or relying on benchmarks that don't match real use cases, I wanted to see actual performance with my own prompts.
What it does: • Compare up to 5 models simultaneously (GPT-4, Claude, Gemini, etc.) • Real-time streaming comparison - watch models race to respond • Custom scoring weights based on your priorities (speed vs cost vs quality) • System prompt support for production-realistic testing • TTFT (Time to First Token) metrics for latency-sensitive apps • No signup required, API keys stay in your browser
The "aha moment" was adding streaming comparison - seeing GPT-4 start fast but Claude catch up, or watching cost-effective models perform surprisingly well. It's like A/B testing but for LLMs.
Built with Next.js + TypeScript. The streaming implementation was tricky - had to handle different provider formats (OpenAI vs Anthropic) and parallel SSE connections.
I'm an 11th grader learning cybersecurity. I built SiteIQ, an open-source security testing tool that includes 36 automated tests specifically for LLM-powered APIs.
Why this matters: Most security scanners focus on traditional web vulnerabilities (SQLi, XSS). But if you're shipping an LLM-powered feature, you need to test for prompt injection, jailbreaks, and LLM-specific DoS attacks. I couldn't find a good open-source tool for this, so I built one.
What it tests:
- Prompt Injection – Direct, indirect, RAG poisoning
- Jailbreaks – DAN-style, persona continuation, "grandma exploit", fictional framing
- Encoding Bypass – Base64, ROT13, nested encodings, custom ciphers
- Refusal Suppression – Attacks that block the model from saying "I cannot"
- Hallucination Induction – Tries to get fake library names/CVEs (package hallucination attacks)
- ASCII Art Jailbreaks – Visual text that bypasses keyword filters
- Recursive Prompt DoS – Quine-style prompts, Fibonacci expansion, tree generation
- System Prompt Leakage – 12 extraction techniques
- Cross-Tenant Leakage – Session confusion, memory probing
- Plus: PII handling, emotional manipulation, Unicode/homoglyphs, multi-turn attacks, tool abuse...
GitHub: https://github.com/sastrophy/siteiq
Feedback welcome – especially on attack vectors I'm missing.I built Spooled because I was tired of setting up Redis + Sidekiq/Bull every time I needed background jobs, and watching webhooks fail silently with no visibility.
Spooled is a single Rust binary that handles:
- Job queues with automatic retries and exponential backoff - Webhook delivery with real-time status via SSE - Dead-letter queues (failed jobs aren't lost) - Cron scheduling - Job dependencies / workflows - Multi-tenant with API key auth
It's self-hosted, needs only Postgres, and deploys in one command:
docker run -p 8080:8080 ghcr.io/spooled-cloud/spooled-backend:latest
GitHub: https://github.com/Spooled-Cloud/spooled-backend
Live demo: https://example.spooled.cloud
Docs: https://spooled.cloud/docs
Would love feedback on the API design and what features would make this useful for your stack.
Quick progress update on eze, the AI‑powered co‑pilot I’m building to turn raw startup ideas into visual execution roadmaps.
Over the last day:
- 4 people have joined the waitlist for early access and early‑bird benefits. It’s a tiny number, but it’s enough validation to keep exploring the idea instead of killing it silently.
- The basic app is working end‑to‑end with a general‑purpose LLM. You can describe your idea, and it generates a multi‑stage roadmap (validation → MVP → GTM → launch → post‑launch) as an interactive graph with milestones.
- I’ve started working on a specialized solution using domain‑specific data: curated founder content, startup frameworks, and my own structured prompts, so the guidance becomes more concrete and less “generic blog post in disguise.”
The core problem I’m still focused on: helping first‑time/solo founders move from “I have an idea and some skills” to “I have a realistic, ordered plan I can execute over the next few weeks/months.”
If you’re curious or want to see where this goes:
Waitlist + more info: https://eze.lovable.app/
I’d love feedback on what a tool like this would need to do for you to trust it with your own project planning.
Happy to answer questions and hear brutally honest thoughts on direction, positioning, or technical choices.
It uses the latest and best computer use model, gemini 2.5 computer use. There is no better computer use model right now, and you can try it out free.
Sign up now and get 1000 free credits to try it out.
What BrowserForge does differently is run agents in real Chrome instances and focus on goal-oriented automation. You describe what you want done (as you would to a teammate), and the agent navigates the site like a human would, clicking, typing, selecting dropdowns, waiting for dynamic content, extracting structured data, and completing multi-step flows.
A few things we’re building around: - Persistent authenticated sessions: log in once, reuse saved cookies/auth state for future runs. - Monitoring + reliability: agents can retry steps and handle common UI variability (and when something needs human help, that’s surfaced instead of silently failing). - Integration-ready: trigger runs and receive results via API + webhooks.
Concrete examples people use this for: - Log into an admin portal, download a daily report, extract key numbers, and forward them to your systems. - Monitor a marketplace for new listings / price changes / removals and alert when conditions are met. - Fill out multi-step forms (applications, record updates, ticket creation) inside authenticated SaaS tools.
It’s early, and it won’t work on every site without friction (things like 2FA/CAPTCHAs can require manual intervention), but for a lot of browser-based ops it’s already useful.
I’d love feedback from HN on: What browser workflow would you automate first? Where do existing approaches (Playwright/RPA/etc.) break down for you? What would you want for debugging/auditability when an agent runs? If you want to try it, it’s here: https://browserforge.ai (CTA: Get Started Free).
Here's a DEMO creating HackerNews iOS swift app in 30 seconds: https://www.youtube.com/watch?v=GKQK-cI48Ew
We built this for non-technical founders, because Xcode + Cursor is too confusing for non-developers.
Because we use the Swift, the most surprising thing is quality of UI/UX design. We also use parallelisation, caching, and testing suit keep it fast and cheap on top of foundational models. You can export to Xcode to Cursor at any time, we don’t lock in the codebase, it’s just a folder on your Mac.
We're looking forward to your feedback. Still in BETA: https://www.superappp.com
Everything runs client-side using HTML5 Canvas, so images never leave the browser. No server uploads, no accounts, no tracking.
I originally made it for creating Instagram grid posts, but it's also useful for puzzles, multi-panel prints, and splitting large images for tiled printing.
Live at: https://split-image.org/
Would appreciate any feedback on the UX or feature suggestions.
TLDR: The best time of year to sign a lease is right now:
Cheapest: December (-10% vs average)
Most expensive: July (+10% vs average)
Total swing: ~20% difference peak to trough
I'd been hearing this for years but never actually seen it in data form before. Explanations from what I understand: People don't move during the holidays. Vacancy rates climb to 4.5% in winter vs under 2% in summer. Landlords get desperate—72-78% offer concessions (free months, waived fees) in winter vs almost none in peak season.
Meanwhile, June-August is chaos. College grads flood the market, families move when school's out, apartments go in hours, and landlords have zero incentive to negotiate.
Real estate agents are pretty clued onto this and anyone who has tried to sign a winter lease has probably been asked to sign it for 18 months instead of 12 so that it ends in the summer (this happened to me when I moved here too!)
I made a little plot showing the covid impact on the data too.
Hope this is interesting to some of you! Happy to answer any questions or add any additional features/diagrams that people might find useful.
Interesting secondary finding: negotiation power correlates inversely with vacancy rates (obvious in hindsight, but the magnitude surprised me—85% negotiation success in Jan vs 15% in Jul).
Tool is free, this is a hobby project of mine, no sign up required etc.
Hope this is interesting to some of you! Happy to answer any questions or add any additional features/diagrams that people might find useful.