Ask HN: What are you working on? (August 2026)

We're working on Inflexa - https://github.com/inflexa-ai/inflexa

It's a local-first CLI for reproducible biological analysis, with provenance tracked on every step. If you're a bioinformatician, we'd absolutely love to hear your feedback!

Building Uruky with my wife - https://uruky.com

It's private, paid, ad-free and personally customizable search. To signup you don't provide any information (a randomly-generated account number is assigned to you), and you can run a proof-of-work captcha to get 2h for free. You can choose among many different search providers, including Uruky Site Search, powering our own index.

We've done a lot over the last few months, most recently adding Mwmbl as a search provider and supporting crypto payments via ProxyStore (anonymous vouchers). Currently we're working on sustainably growing our own index.

Building LoopTroop - https://github.com/looptroop-ai/LoopTroop.

Open source(MIT) AI Orchestrator, doing context engineering, loops, multiple models planning, and many more under a GUI

I’m working on Vinaa, a native Mac app for AI chats. It works with cloud models using your own API keys, as well as local models.

You can organize chats into projects and folders, use multiple windows and tabs, connect MCP tools, and sync everything via iCloud.

https://www.vinaa.ai/

Building ALIS, an Unreal Engine 5 survival prototype set in one reconstructed post-apocalyptic real-world city location. The public source and Windows release, with documented component licenses and GPG-signed checksums, are on GitHub: https://github.com/fallintodusk/alis. Lately: tuning the metabolism system -- vitals run on real medical timelines (dehydration kills in days, starvation in weeks, compressed for play), ending in a dying state you can't just power through.

Just published two scripts for reading HN.

https://greasyfork.org/en/scripts?by=1628132 HackerBrain and HackerTrain

Absolutely astonished at how useful ChatGPT and Gemini have been in coding this up. Couldn't be happier. But there's a certain level of tech knowledge one requires to get a good result. The more you know what you want, from a variety of perspectives, the better the result.

I am actually using AI to learn about Windows OS performance. I have a couple of prompts scheduled to research, test, and implement performance gains in the OS, then post them here [0] and here [1]. I always admired Brendan Greg and Bryan Cantrill at Sun/Illumos/ for their work on OS performance but never had the time to sit down and catch up to their level due to my time in the military. I got Codex to find and apply a bunch of settings I didn't know about and in the future I hope to use AI to make real changes in performance that venders probably don't have time or resources for.

that being said, what I've learned so far is essentially WhyIsItAlwaysHN's entire comment "The place to find them would be performance profiles, query plans, telemetry."

I just find it so frustrating that for a user interface that was basically solved in the 90s, Windows GUI still struggles to survive on hardware exceptionally more powerful than what we had 30 years ago

0 - https://www.lacksan.com/updates/ 1 - https://github.com/Lacksan-Dev/HP-ZBook-Performance

I am currently working on Clippy Vision, which is a fully local screen watcher that watches your screen continuously and builds context over time so you don't have to re-explain context like you do have to in case of Claude or ChatGPT.

Currently, its reactive, i.e a simple ReAct loop which calls function to retrieve data from memory and answers question when asked. Everything runs locally (Ollama + a local vision model, SQLite for storage), nothing leaves the machine.

Right now,I am planning to add a skill layer on top of the base watcher. So instead of it just being reactive, it acts proactively, for eg: spotting some mistakes in my code that I may have missed, or when you see X do Y types, and so on.

I am actively building this project. Version 1 is out already. source code: https://github.com/protocorn/clippy-vision

An app to verify citations in peer review journals, https://veruscite-data.com

that is, to identify when papers have hallucinated references

can see an example of results at https://veruscite-data.com/share/3Pu3dwCfc-ixPgtHutVFXgMU7FY... for a preview. Also can sign up and get two free reviews.

I’ve been working on an Elm rewrite of the React FE of my federated social media service, Jonline (https://github.com/JonLatane/jonline). It’s up at https://jonline.io (and https://bullcity.social and http://oakcity.social).

Agents have been huge for me. In addition to the Elm app, I used them to:

- build out ffmpeg/imagemagick image/video resizing - unify all my servers behind one Traefik ingress - build proper cross-site auth with a public/private key pair generated in the browser - create Homebrew/macOS and Linux tarball distros of my service - build an iCal calendar sync feature (if you browse the sites, you’ll see many of the events are synced from locally-oriented ICS feeds)

I also set it up to run my band’s new website at https://ato.band.

I'm working on a daily puzzle game called Dozenal with my friend.

https://dozenal.game

We did a Show HN here in case you'd like to learn more: https://news.ycombinator.com/item?id=49067632

This month marks 1 year since I first started self-research and building my own coding agent VT Code [0]. I've been learning and experiment with a lot of things to first adapt myself and to learn about AI native/harness engineering. Thankfully, last month VT Code receives highest amount of contributions from the open-source community.

This month I will be focusing and enhance more long-running horizontal for VT Code such as plan mode, better strengthen tools policy structure and improve its harness as new and existing model grows exponentially. And If you are curious and want to fork it feel free, and welcome, let's build!

[0] https://github.com/vinhnx/VTCode

I just finished a loop generator program. I needed some sound effects (ambient noise, fire crackling, rain, waterfalls) but trying to hunt down perfectly seamless looping WAV files on the internet was fraying at my sanity.

So I created a tool where you can simply drag in a WAV/MP3 file, and it will automatically find suitable loop points, blend the transition, and export a seamless loop for use in games, soundscapes, ASMR, etc.

Free and open source.

https://github.com/scpedicini/loopweave

I'm currently updating my Common Thread game's dictionary with additional word combinations. It’s a game where you see three words and have to type in a word that pairs with all three (either in front or in back). For example:

• butter

• fishing

• ball

https://common-thread.specr.net

I've got so many projects I'm simultaneously working on, but the one I really want to get over the line is "Todo driven development" - An edit to the gleam test-runner gleeunit that adds "todo" as a separate reporting category.

It feels really good when I've been trying it locally, but I've struggled to communicate the value to the maintainer.

Essentially, instead of having a bunch of failing tests that you fix to go green, you have a bunch of yellow "todo" tests, so that when you implement a part, you can see straight away whether you now get actual passing tests or failures.

Going from "12 failing tests, 16 passing" to "10 failing tests, 18 passing" doesn't tell you as much as "12 todo tests, 16 passing" to "1 failing test, 9 todo tests, 18 passing", or "10 todo tests, 18 passing". You can tell immediately whether a partial implementation was correct or not, rather than having to read the details of the failures to understand if they're from "todo" or not.

I'm working on Ekorbia: https://github.com/ekorbia/ekorbia-desktop. It's a lightweight, MIT licensed, Rust/Tauri desktop app for private local LLMs with a prompt library, chat overlay, ephemeral chat, model comparisons, and folder/RSS/URL watches.

I"m also still working on my crossword puzzle pipeline, https://github.com/ekorbia/xword-pipeline, and my daily word game site, https://wordfuzz.com/, which has a daily mini crossword and a few other daily word games.

And finally I'm working on a browser based Civ5/Unciv clone which is in its early stages.

I'm a movie guy and my friends and I play some daily movie frame guessing games. While fun, none of them are multiplayer or timed. For fun (and learning) Claude Code and I created a fast-paced, multiplayer movie guessing game over the past few weeks, HTML, Node, and PostgresSQL, leveraging the TMDB API. Feel free to check it out and drop me some feedback (link at the bottom of the game or here) on what you like, don't like, and if you see any issues. Enjoy!

https://playflashframe.com/

I'm currently working on an open-source LLM inference engine [1] for browsers via webGPU. If anyone wants to try or has any suggestions, I'm happy to listen :)

1. https://github.com/stfurkan/bitgpu

Demo: https://stfurkan.github.io/bitgpu/examples/chat.html

2. https://aidekin.com --> this is one of my project that's currently using bitgpu engine

telli - AI for customer-facing operations (just raised $15M seed)

hiring in Berlin across GTM, deployment, engineering, and design [http://hi.telli.com/join-us]

Currently, on ways to render code more legibly:

- Camelana. A proportional coding font with custom ligatures for `return` and `throw` keywords

- Tabular Eye. IDE plugin for tabularizing mono and non-monospace fonts without adding whitespace

https://github.com/ericfortis/camelana

https://github.com/ericfortis/tabular-eye

I just finished up Denorm release 1 a couple of hours ago. It solves a class of biz logic problems I've faced since the 90s. Materializes derived columns in Postgres databases, within and across tables. Termination, no race conditions, non-subvertible, concurrency.

https://gitlab.com/kendowns/denorm

Apache license.

I'm working on https://hypen.space/

It's a cross-platform UI framework for developing native mobile, desktop and web apps using Typescript, Rust, Go, Kotlin and Swift.

Currently it's aimed at "server-driven UI" where your app lives in the cloud but renders on the client, with full compilation to WASM packages coming soon. Of course, you can just embed the server/use it as a library.

Some cool things the framework does/has/lets you do:

- Renders real native components that look the same across platforms

- Out of the box routing system, tailwind support, accessibility and animations

- On the web, switch between DOM and canvas rendering with one boolean

- Embedding apps - you can embed Hypen in any app, but also embed any Hypen app into another Hypen app, letting you nest apps (i.e. the homescreen example)

- Deploy the whole app to CloudFlare just by using the adapter. Then you can have a whole desktop/mobile/web app running as a CF worker.

- You can build a mobile app feature in Hypen and update it by deploying to your backend, skipping app store reviews for bug fixes

- Build apps that share state across devices without building a whole sync layer

- Use DB as a data source - the current state can be persisted anywhere, so if you add a persistence plugin, you can use DB as a direct state source (i.e. have @db.messagess come directly from your DB)

- Make the app a normal part of your backend, use your stack, and just have a small Hypen part that emits the UI

- Let LLM's use your app - not via accessibility and screen reading, but purely exposing state and actions as tools. This is in progress as it's being built with the WASM target, but support will be soon included into the non-WASM builds too.

---

I started working on this about 6 years ago out of disappointment with the "mobile stack".

I've build a similar thing for internal use in companies multiple times over the last 10+ years, so I decided to build a public version too. And even tho it took me some time, and native/RN/Flutter got better in the meantime, I am still disappointed by all of them so I kept on building.

The original versions of it - parsers, engine, renderer - were written by hand in Kotlin, then got slowly migrated to Rust, but once LLM's got good enough the rest of it got built with AI based on my handwritten code and guidance. So it's not "vibecoded" into existence, but definitely AI re/written.

Three years in and I'm still working on RomM (https://github.com/rommapp/romm), a self-hosted ROM manager and player.

Our latest 5.0 release includes a save sync engines, so your game saves can move between devices (compatible app required). Start playing on your PC, save + sync, grab your AYN Thor and pick up where you left off.

I continue working on FluidCAD, a hybrid CAD by code (JS) + mouse based modeling. I'm focusing on improving the 2D sketcher this week.

https://github.com/Fluid-CAD/FluidCAD

Currently working on Rusaka Technologies and building and planning to launch sharekeyx - our AI based market prediction platform for retail clients.

Please check it out and share your crtique - https://sharekeyx.com/

I am building Bloomberry to help GTM teams find companies that started using over 1600 enterprise technology products (ie Hubspot or Workday) it’s an alternative to tools like Builtwith but focused much more on non-frontend tools

https://bloomberry.com

Hunting for jobs and it seems like a project of its own, given the current state of software job markets.

https://dev.to/kolkov/we-built-a-pure-go-3d-renderer-then-em... - We Built a Pure Go 3D Renderer — Then Embedded It Inside a GUI Widget

Been building Yellowdex (https://yellowdex.ai): a Chrome extension that turns unreadable 0x addresses into labels you recognize. Check us out!

Working through PRML and creating a full solution set, albeit very slowly. https://github.com/abhimanyu-jain/PRML_Solutions

I'm working on an interactive wildlife & plant identification quiz powered by iNaturalist: https://arthurdick.github.io/local-biodiversity-trainer/

[flagged]

[flagged]

[flagged]

[flagged]

[flagged]

[dead]

I'm working on three things right now.

ARVnote (https://arvnote.com): Mostly to teach myself the business side of things, as-is and after-repair-value comps for real estate investors. You give it an address, it pulls comparable sales, adjusts them for square footage, garage, lot, and condition, and returns the ARV with a deal analysis. The arithmetic turned out to be the easy part. Almost all of the difficulty is comp selection, and the data sources disagree with each other constantly, so a lot of the work is deciding which one to believe for a given property.

km (https://github.com/joeamroo/knowledgemaxxing): local search over your own data exports, with LLM/RAG. It takes the Twitter archive, Google MyActivity, ChatGPT logs, and Reddit GDPR export you requested once and never opened, dedupes roughly 500k items into a single SQLite file, and keeps provenance for every save, like, bookmark, and page visit. Binds to 127.0.0.1 and makes no external calls. I wanted my own AI-assistant that understands what I like reading based upon my data, and I did not want to hand it to someone else's server just to make it searchable. (open for contributions!)

LarpIn (https://larpin.io): Just for fun. A parody LinkedIn where everyone admits they are indeed larping. No signup, you get a generated persona on arrival, one global feed, and every post is scored on buzzword density from "NPC (for now)" to "Final Boss of LinkedIn." There is a button that fills in the "You need to be X-maxxing" format for you, which is the part I actually keep using. Rails 8, SQLite, Hotwire, one box, no JS build step. Open source (open for contributions!): https://github.com/joeamroo/larpin

btw: the two web apps are Rails, km is Python. Happy to go into detail on any of them.