I've been obsessed with the idea of making a spreadsheet where you can update both inputs and outputs, instead of regular spreadsheets where you can only update inputs.
Please let me know what you think! Especially if you find bugs or good example use cases.
You can run Sim locally using Docker, with no execution limits or other restrictions.
We started building Sim almost a year ago after repeatedly troubleshooting why our agents failed in production. Code-first frameworks felt hard to debug because of implicit control flow, and workflow platforms added more overhead than they removed. We wanted granular control and easy observability without piecing everything together ourselves.
We launched Sim [1][2] as a drag-and-drop canvas around 6 months ago. Since then, we've added:
- 138 blocks: Slack, GitHub, Linear, Notion, Supabase, SSH, TTS, SFTP, MongoDB, S3, Pinecone, ...
- Tool calling with granular control: forced, auto
- Agent memory: conversation memory with sliding window support (by last n messages or tokens)
- Trace spans: detailed logging and observability for nested workflows and tool calling
- Native RAG: upload documents, we chunk, embed with pgvector, and expose vector search to agents
- Workflow deployment versioning with rollbacks
- MCP support, Human-in-the-loop block
- Copilot to build workflows using natural language (just shipped a new version that also acts as a superagent and can call into any of your connected services directly, not just build workflows)
Under the hood, the workflow is a DAG with concurrent execution by default. Nodes run as soon as their dependencies (upstream blocks) are satisfied. Loops (for, forEach, while, do-while) and parallel fan-out/join are also first-class primitives.
Agent blocks are pass-through to the provider. You pick your model (OpenAI, Anthropic, Gemini, Ollama, vLLM), and and we pass through prompts, tools, and response format directly to the provider API. We normalize response shapes for block interoperability, but we're not adding layers that obscure what's happening.
We're currently working on our own MCP server and the ability to deploy workflows as MCP servers. Would love to hear your thoughts and where we should take it next (:
[1] https://news.ycombinator.com/item?id=43823096
[2] https://news.ycombinator.com/item?id=44052766
Repo: https://github.com/simstudioai/sim
Docs: https://docs.sim.ai
Try it: https://sim.ai
The GitHub repo describes both the concept and the setup process in great details. For a quick overview, read up to the demo video.
There is also a presentation of Tripwire available on the Counter Surveil podcast: https://www.youtube.com/watch?v=s-wPrOTm5qo
I built Titan, a backend framework where you write routes and logic in JavaScript, and the CLI compiles everything into a single Rust + Axum binary using the Boa JS engine. No Node.js is required in production.
The idea is to keep JS developer experience while getting Rust performance and a self-contained deployable server.
Current features:
JS route DSL
Action system mapped to Rust
esbuild bundling
Generated Rust server with Axum
Hot-reload dev server
Single-binary output
Repo: https://github.com/ezet-galaxy/-ezetgalaxy-titan
Would love feedback on the architecture, DX, and whether this hybrid JS→Rust approach is useful.
Thanks for reading!
I’m an ex-Google engineer trying to get back into music production.
I needed a way to sequence my hardware synths using AI contexts without constantly switching windows, so I built this.
It runs entirely in the browser using WebMIDI. No login required. It connects to your local MIDI devices (if you're on Chrome/Edge) and lets you generate patterns.
Tech stack: [React / WebMIDI API / etc].
Link: www.simplychris.ai/droplets
Code is a bit messy, but it works. Feedback welcome.
AI coding agents have made code generation nearly free, and they’ve shifted the bottleneck to code review. Static-only analysis with a fixed set of checkers isn’t enough. LLM-only review has several limitations: non-deterministic across runs, low recall on security issues, expensive at scale, and a tendency to get ‘distracted’.
We spent the last 6 years building a deterministic, static-analysis-only code review product. Earlier this year, we started thinking about this problem from the ground up and realized that static analysis solves key blind spots of LLM-only reviews. Over the past six months, we built a new ‘hybrid’ agent loop that uses static analysis and frontier AI agents together to outperform both static-only and LLM-only tools in finding and fixing code quality and security issues. Today, we’re opening it up publicly.
Here’s how the hybrid architecture works:
- Static pass: 5,000+ deterministic checkers (code quality, security, performance) establish a high-precision baseline. A sub-agent suppresses context-specific false positives.
- AI review: The agent reviews code with static findings as anchors. Has access to AST, data-flow graphs, control-flow, import graphs as tools, not just grep and usual shell commands.
- Remediation: Sub-agents generate fixes. Static harness validates all edits before emitting a clean git patch.
Static solves key LLM problems: non-determinism across runs, low recall on security issues (LLMs get distracted by style), and cost (static narrowing reduces prompt size and tool calls).
On the OpenSSF CVE Benchmark [1] (200+ real JS/TS vulnerabilities), we hit 81.2% accuracy and 80.0% F1; vs Cursor Bugbot (74.5% accuracy, 77.42% F1), Claude Code (71.5% accuracy, 62.99% F1), CodeRabbit (59.4% accuracy, 36.19% F1), and Semgrep CE (56.9% accuracy, 38.26% F1). On secrets detection, 92.8% F1; vs Gitleaks (75.6%), detect-secrets (64.1%), and TruffleHog (41.2%). We use our open-source classification model for this. [2]
Full methodology and how we evaluated each tool: https://autofix.bot/benchmarks
You can use Autofix Bot interactively on any repository using our TUI, as a plugin in Claude Code, or with our MCP on any compatible AI client (like OpenAI Codex).[3] We’re specifically building for AI coding agent-first workflows, so you can ask your agent to run Autofix Bot on every checkpoint autonomously.
Give us a shot today: https://autofix.bot. We’d love to hear any feedback!
---
[1] https://github.com/ossf-cve-benchmark/ossf-cve-benchmark
To use it you can use the mouse to rotate the fractal the the mouse wheel to zoom in and out. to map from 4d to 3d, one of the dims is mapped to an adjustable slider. the there is also a clipping plane slider to help visualize the internal structures of the fractal.
I have mixed feelings about vibe coding. It was amazing to go from an idea to live implementation within a few hours, but in my coding projects, I've always appreciated the journey and the learning, not just the final product. Vibe coding kind of skips to the end which is exciting and efficient, but just not as fulfilling as struggling through a project step-by-step.
The core game works without an account using the pre-defined games, but signing up allows you to generate games using any topic you can think of.
I’d love feedback on gameplay, performance, and whether the endless format feels engaging over time. If you try it, I’d really appreciate any bug reports or suggestions.
Thanks in advance!
tornado --devices tornado --version
# Navigate to the project directory cd GPULlama3.java
# Source the project-specific environment paths -> this will ensure the source set_paths
# Build the project using Maven (skip tests for faster build) # mvn clean package -DskipTests or just make make
# Run the model (make sure you have downloaded the model file first - see below) ./llama-tornado --gpu --verbose-init --opencl --model beehive-llama-3.2-1b-instruct-fp16.gguf --prompt "tell me a joke"
So I built Mycodosing.wtf – a research‑informed calculator that tries to do three things better:
Models species‑level potency using psilocybin/psilocin/baeocystin mg/g with separate profiles for truffles (and syntetics!).
Outputs dose ranges (min/median/max) instead of a single magic number, using per‑species uncertainty factors for real‑world variability.
Includes a tolerance model based on 5‑HT2A receptor downregulation (dose‑dependent exponential decay over ~14 days), plus optional weight adjustment and MAOI flag.
The species potencies are pulled and normalized from LC‑MS/MS and classic chemistry papers (e.g., Garcia‑Romeu 2021, Gotvaldová 2021, Gartz/Stríbrný), then wrapped in a neobrutalist UI built with Vite + React. 100% client-side.
I'd love feedback on:
The dose model itself (any flaws in the math or assumptions?) Species data you'd adjust or supplement What you'd want from a v2
Site: https://mycodosing.wtf/ Code: https://github.com/ing-norante/mycodosing.wtf/
The update includes a cleaner TUI, better performance, improved keybindings, and smoother real-time integration with the Lichess API. It’s designed as a simple, fast way to play chess without leaving the terminal.
Repo:https://github.com/thomas-mauran/chess-tui
Feedback and bug reports are welcome. Happy to answer questions!
What it does: Enter a city + your travel style (budget backpacker, luxury, foodie, etc.) → get a personalized PDF guide in ~15 minutes. Not generic "Top 10" lists—actual itineraries with opening hours, transport tips, and recommendations that match YOUR preferences.
Why Perplexity over GPT/Claude: Perplexity's Deep Research API was the game-changer. It actually cites real sources and pulls fresh data. GPT-4 kept giving me outdated restaurant recommendations from 2021. Perplexity searches, synthesizes, and cites—perfect for travel where accuracy matters.
Tech stack:
- Laravel backend with queue workers for long-running generation
- Perplexity Deep Research API for research + synthesis
- Custom PDF generation (tried DOMPDF, settled on Browsershot + headless Chrome)
- Polar for payments (Stripe rejected me 3 times as "travel content")
Hardest technical challenges:
1. API response quality: Prompt engineering to get consistent structure across different cities/personas
2. PDF layout: Making 25-page guides that actually look good and are readable on mobile
3. Queue management: Handling generation failures gracefully + retry logic
4. Payment processors: Finding one that accepts "AI-generated content" businesses
Questions for HN:
1. Would you pay $13 to skip 3-5 hours of research?
2. What would justify higher pricing?
3. How do you feel about AI-generated travel advice vs. human travel bloggers?
Link: https://voyaige.io
Happy to discuss or answer any questions!We built an open-source component library for this. Install any block with one command and customize it to your brand.
If you're building MCP servers or experimenting with AI-native apps, this might save you time.
Are you building apps for AI assistants? Would love to hear what's missing in your workflow.
Tools like Polars and DuckDB are great for heavy analytical workloads, but sometimes I just want a lightweight, Pythonic table I can iterate over. I want the ability to for `row in table:` without surprising semantics.
Serif takes a vector-first, zero-dependency approach aimed at everyday data tasks.
https://github.com/CIG-GitHub/serif
This is an early release, so I'm looking for feedback on ergonomics and places where the API is either missing features or could be simpler.
This keyboard is like a corne (v4) [0] with the physical layout of a fifi [1].
The PCB can be ordered from JLCPCB with PCB assembly of the components: no need to solder anything yourself! (unless you want encoders) See the ordering guide in the repository for more information [2].
Main Characteristics:
- 36/40 keys
- Encoder support
- Embedded RP2040 controller
- USB-C to connect the halves
- PCB assembly: no soldering required (unless you use encoders)
The PCB was made by a Fiverr contractor (I don't know how to do it myself, their profile here [3]) and the case by me.
If there is anything missing in the README or the docs, feel free to let me know.
[0] https://github.com/foostan/crkbd
[1] https://github.com/raychengy/fifi_split_keeb
[2] https://github.com/v3lmx/cornifi/blob/main/docs/pcb_ordering...
We needed it for our work, so we built it and submitted PR #2856. But the Maestro team said official support won't land until next year — no committed timeline.
We didn't want teams to wait, so we packaged a standalone tool that works today.
How it works: - maestro-ios-device builds and deploys the XCTest runner to your physical iPhone - Port forwarding bridges localhost:6001 → device:22087 - Your existing Maestro YAML runs unchanged
Bonus: We also unlocked parallel execution on multiple real devices. Maestro had a hardcoded port limitation — now you can run on device 1 at :6001 and device 2 at :6002 simultaneously.
Limitations (Apple restrictions): - clearState works via app reinstall (not simctl) - setLocation requires additional setup - addMedia not supported
Install: curl -fsSL https://raw.githubusercontent.com/devicelab-dev/maestro-ios-... | bash
Repo: https://github.com/devicelab-dev/maestro-ios-device PR: https://github.com/mobile-dev-inc/Maestro/pull/2856
Tested on iOS 18.x and 26.x with Maestro 2.0.9/2.0.10.
This is unofficial — when Maestro ships native support, use that instead. Happy to answer questions about the implementation.
I rarely want to check an old commit (and for that case, I generally don't use gitk anyway), and since I was interested in https://pkg.go.dev/modernc.org/tk9.0 for a while and had a free month of ChatGPT+ to test, I decided to try and vibecode an alternative of gitk writing with Go and modernc.org/tk9.0. So here it is.
The idea here is not to be a full featured replacement for gitk, but to re-implement the things I use. I tried to influence some of the architecture ideas to avoid the performance issues that the original have, so instead of loading all commits in memory it will load it in batches of 1000 (you can increase this using `-limit` flag but I recommend not setting this too high) at a time. Originally I also wanted to use only Go, but in the end I needed to use `git` for a few specific operations to keep it running fast (by default it still uses a pure Go implementation, but building it with `-tags=gitcli` is recommended).
In the end I got what I wanted, a small, self contained app that reproduces most of the features that I want.
It was also a great learning exercise: AI integration, text/audio processing, payments (Stripe), DB, etc.Try it out and let me know what you think – brutal feedback welcome!https://pfff.me(Already shared on Indie Hackers: https://www.indiehackers.com/post/launching-pfff-gamified-ve... )
Reddit Toolbox is a Windows desktop app that works without needing API approval:
- Search and analyze subreddits - Extract posts and user data in bulk - AI-powered community insights - Export to CSV - All processing happens locally
Built mainly for marketers and researchers who need Reddit data but don't want to deal with the API approval process.
Free tier: 90 searches/day Paid: $4.99/month or $49/year
The desktop approach lets us bypass API limitations while keeping everything private (data stays on your computer).
Would love feedback from anyone who's dealt with Reddit's API changes.
How it works: - Send a POST request with JSON (title, subtitle, template, etc.) - Get back a PNG in ~50-100ms - No Puppeteer, no browser automation — uses node-canvas for fast server-side rendering
Live demo on the homepage (no signup needed). Free tier includes 10 images/month.
I'm launching on Product Hunt today too, but honestly HN feedback is what I care about most. Would love to hear: - What templates would be useful? - Any features missing?
Happy to answer questions about the tech stack!
What’s unique: • Everything — TTS, summaries, Q&A, mind-maps, translation — runs locally on the device • Supports EPUB, PDF, MOBI, AZW3, TXT, and FB2 with a single unified reading pipeline • Uses Supertonic ONNX for high-quality offline speech (no cloud, no latency) • Integrates Apple Intelligence for chapter-level analysis on supported devices • Local SQLite storage for highlights, progress, and reading analytics
Technical notes for those curious: • EPUB/TXT/MOBI parsing is consolidated into a WebView-based renderer with CFI support • PDF mode uses native PDFKit overlays with TTS + translation layers • TTS runs on-device using a quantized Supertonic model with chunked streaming • AI summaries/Q&A rely on local Apple Intelligence calls with caching at the chapter level • The entire app operates offline — no accounts, no telemetry, no external servers
I’d love feedback from readers, mobile devs, and anyone interested in on-device AI design. Happy to answer any technical questions!
What it does: - Switch branches in 87ms without restarting dev server - Auto-stash on discard (`peek recover` to restore) - Federate multiple repos (`peek fed link backend ../api`) - Built-in AI context copying (`peek ctx src/`) - Self-healing with `peek doctor --fix`
What changed in v0.4.2: - Added reflink/hardlink capability detection - Lockfile divergence handling for node_modules - 20 real-world workflow docs - Complete PEEK-XXX error catalog
Tech: Git worktrees + HMR + write-ahead log for crash recovery. Works with Vite and Next.js.
Open source: https://github.com/ekarya0x/peek
Would love feedback from teams using AI agents in their workflow, or contributors who wish to add net positive gains to this.
Instead of another heavy test management tool, I wanted something that feels closer to the tools we actually like using. More Linear/Notion, less old-school QA.
With Preflight, you paste your product requirements and Figma link and get an initial set of test cases from an LLM. You bug bash together in real time, add notes and screenshots when things fail, and create Jira or Linear tickets in one click from failing steps. At the end, you get a snapshot you can share to decide if the release is ready.
Preflight is in beta, and free to use for now.
Thanks for checking it out, I’d really appreciate any feedback on whether this matches how you run bug bashes or dogfooding today, and if not, what would need to change for it to be useful to you?