Ask HN: What Are You Working On? (March 2026)

I started developing a city builder called Metropolis 1998 [1], but wanted to take the genre in new directions, building on top of what modern games have to offer:

- Watch what's happening inside buildings and design your own (optional)

- Change demand to a per-business level

- Bring the pixel art 3D render aesthetic back from the dead (e.g RollerCoaster Tycoon) [2]

I just updated my Steam page with some recent snapshots from my game. Im really happy with how the game is turning out!

[1] https://store.steampowered.com/app/2287430/Metropolis_1998/

[2] The art in my game is hand drawn though

https://github.com/keithn/yt

Also working on a language for embedded bare-metal devices with built-in cooperative multitasking.

A lot of embedded projects introduce an RTOS and then end up inheriting the complexity that comes with it. The idea here is to keep the mental model simple: every `[]` block runs independently and automatically yields after each logical line of code.

There is also an event/messaging system:

- Blocks can be triggered by events: `[>event params ...]`

- Blocks can wait for events internally

- Events can also be injected from interrupts

This makes it easy to model embedded systems as independent state machines while still monitoring device state.

Right now it’s mostly an interpreter written in Rust, but it can also emit C code. I’m still experimenting with syntax.

Example:

    module WaterTank {
      type Direction = UP|DOWN
      let direction = UP
      let current = 0

      [>open_valve direction |> direction]
      [>update level |> current]

      [
        for 0..30 |> iteration {
          when direction {
            UP   -> !update level=current + 1 |> min(100)
            DOWN -> !update level=current - 1 |> max(0)
          } ~
          %'{iteration} {current}'
        }
      ]

      [>update level |> when {
          0..10  -> %'shallow'
          11..15 -> %'good'
          16..   -> %'too much!' then !open_valve direction=DOWN
        }
      ]
    }

https://IsThisAI.lol

The content is hand picked from tiktok, Instagram, Facebook, Reddit and other AI generating platforms.

Honestly I don't know where I'm going with this, but I felt the urge to create it, so here it is.

I learned how to optimize serving assets on CloudFlare.

Feedback welcome.

It just won an award! It was awarded Players' Choice out of 700 daily web games at the Playlin awards: https://playlin.io/news/announcing-the-2025-playlin-awards-w...

Right now around 3,500 people play every day which kind of blows my mind!

It's free, web-based, and responsive. It was inspired by board games and crosswords.

I've been troubleshooting some iOS performance issues, working on user accounts, and getting ready to launch player-submitted puzzles. It's slow going though because I have limited free time and making the puzzles is time consuming!

Here's an article with more info about the award: https://cogconnected.com/2026/03/tiled-words-crowned-the-pla...

Im also building https://www.keepfiled.com, a microsaas to save emails (or email attachments) to google drive

I almost forgot, I also built https://statphone.com - One emergency number that rings your whole family and breaks through DND.

I love building. I built all these for myself. unfortunately I suck at marketing so I barely have customers.

It's an addictive slot machine where I pull the lever and the dials spin as I hope for the sound of a jackpot. 999 out of 1000 winning models do so because of look-ahead bias, which makes them look great but are actually bad models. For example, one didn't convert the time zone from UTC to EST, so five hours of future knowledge got baked into the model. Another used `SELECT DISTINCT`, which chose a value at random during a 0–5 hour window — meaning 0–5 hours of future knowledge got baked in. That one was somehow related to Timescale hypertables.

Now I'm applying the VIX formula to TSLA options trades to see if I can take research papers about trading with VIX and apply them to TSLA.

Whatever the case, I've learned a lot about working with LLM agents and time-series data, and very little about actually trading equities and derivatives.

(I did 100% beat SPY with a train/out-of-sample test, though not by much. I'll likely share it here in a couple weeks. It automates trading on Robinhood, which is pretty cool.)

Pipeline so far has gone like this:

* Use the search engine's API to query a bunch of depravity

* Use qwen3.5 to label the search results and generate training data

* Try to use fasttext to create a fast model

* Get good results in theory but awful results in practice because it picks up weird features

* Yolo implement a small neural net using hand selected input features instead

* Train using fasttext training data

* Do a pretty good job

* for (;;) Apply the model to real a world link database and relabel positive findings with qwen to provide more training data

Currently this is where I'm at

  Accuracy:   90.90%
  True  Positive: 1021
  False Positive: 154
  True  Negative: 2816
  False Negative: 230
  Precision:  0.8689
  Recall:     0.8161
  F1:         0.8417

I have been working on it as side project for over two years and now, with funding from the EU for the next 2.5 years, I hope I can make of it a real product for everyone to use that can compete with the likes of Excel and Googl;e Sheets.

I can oly say, I am overly, off the Moon excited

[1]: https://www.ironcalc.com

We’ve continued to get some paid customers and have exited beta last week, given everyone seemed to be quite satisfied and there hadn't been requests for changes, only some specific search providers.

Because of bots there isn’t a free trial easily available, but if you’re a human and you’d like to try it for a couple of days for free, reach out with your account number and we’ll set that up!

Thanks.

P.S.: Because people have asked before, our tech stack is intentionally very "boring" (as in, it generates and serves the HTML + bits of JS to enhance settings and such — search can be done without JS), using Deno in the backend (for easier TypeScript), PostgreSQL for the DB, and Docker for easier deploying.

[1] https://uruky.com

Hister is basically a full text indexer which saves all the visited pages rendered by your browser. It provides a flexible web (and terminal) search interface & query language to explore previously visited content with ease or quickly fall back to traditional search engines.

Here's a little summary of the background/motivation/beginnings: https://hister.org/posts/how-i-cut-my-google-search-dependen...

Project site: https://github.com/asciimoo/hister

Website: https://hister.org/ Read-only demo: https://demo.hister.org/

The front bump out leaks when we get driving rain. I installed some flashing but that wasn't enough, it's still leaking. So I'm working on that so I can close up the big hole in the ceiling some day.

The prior owners filled in the old coal chute with literal bags of cement sort of artistically placed in the hole in the brick foundation. So I'm trying to figure out what masonry tools and skills I'll need to close it up proper.

I'd like to build my kids a playhouse of some sort, sketching out some designs for that.

I'm building a lightweight screen recorder for macOS. It supports lots of features you'd expect from a professional screen recorder such as ProRes 422/4444, HEVC/H.265, and H.264, capturing alpha channels and supports HDR. Frame rates from 24 to 120fps. Can capture system audio and mic simultaneously. You can also exclude specific things from recordings, like the menu bar, dock, or wallpaper.

No tracking, no analytics, no cloud uploads, no account. MIT licensed. Everything stays on your Mac. Still early, but happy to hear feedback!

The stock firmware is horrible but the community has this firmware called CrossPoint. I wanted to be able to upload, manage files etc. from my iPhone on the go and also send over web articles. So I build this app CrossPoint Sync https://crosspointsync.com to do just that.

I've already published it on App Store and pending publishing on Android. The community is niche and has also been using the app, so its been fun building for my use and in turn also getting good feedback from community.

If you are using the Xteink and CrossPoint firmware, then give the app a try.

iOS App Store: https://apps.apple.com/app/crosspoint-sync/id6758985427

Android Beta: https://crosspointsync.com/android/join-beta

GitHub: https://github.com/zabirauf/crosspoint-sync

while word_count < x: write_next_chapter(outline, summary_so_far, previous_chapter_text)

It worked well enough that the novels were better than the median novel aimed at my son's age group, but I'm pretty sure we can do better.

There are web-based tools to help fiction authors to keep their stories straight: they use some data structures to store details about the world, the characters, the plot, the subplots etc., and how they change during each chapter.

I am trying to make an agent skill that has two parts:

- the SKILL.md that defines the goal (what criteria the novel must satisfy to be complete and good) and the general method

- some other md files that describe different roles (planner, author, editor, lore keeper, plot consistency checker etc.)

- a python file which the agent uses as the interface into the data structure (I want it to have a strong structure, and I don't like the idea of the agent just editing a bunch of json files directly)

For the first few iterations, I'm using cheap models (Gemini Flash ones) to generate the stories, and Opus 4.6 to provide feedback. Once I think the skill is described sufficiently well, I'll use a more powerful model for generation and read the resulting novel myself.

One of the issues I encountered initially was that the LLMs were repeating a small set of actions and never trying some of the more experimental actions. With a bit of prompt tweaking I was able to get them to branch out a bit, but it still feels like there's a lot of room for improvement on that front. I still haven't figured out how to instill a creative spark for exploration through my prompting skills.

It has been quite exciting to see how quickly a few simple rules can lead to emergent storytelling. One of the actions I added was the ability for the agents to pray to the creator of their world (i.e. me) along with the ability for me to respond in a separate cycle. The first prayer I received was from an agent that decided to wade into a river and kneel, just to offer a moment in stillness. Imagining it is still making me smile.

Unfortunately, I don't have access to enough compute to run a bigger experiment, but I think it would be really interesting to create lots of seed worlds / codebases which exist in a loop. With the twist being that after each cycle the agents can all suggest changes to their world. This would've previously been quite difficult, but I think it could be viable with current agentic programming capabilities. I wonder what a world with different LLM distributions would look like after a few iterations. What kind of worlds would Gemini, Claude, Grok, or ChatGPT create? And what if they're all put in the same world, which ones become the dominant force?

It feels like a small change, but it really makes sense in my brain and I'm glad I finally made it happen. My services feel properly positioned under these distinct brands. Now of course when I get time I need to redesign both of my own websites.

Ideas wise... I like the static website world. I use 11ty, but there are others moving in this direction. Clean, performant, simple html / css / js websites that should last for decades. I like the idea of publishing them to IPFS, creating an indie web with some permanence to it.

We just launched a portfolio for Director of Photography Joel Honeywell: https://joelhoneywell.com/

This is a simple static site, no CMS, built with 11ty.

I also intend to dig into how to integrate Emacs with tools such as yt-dlp and patreon-dl to grab Latin-language audio content from the Internet, transcode the audio with ffmpeg, load it into the LLM's context window, and send it off for transcription. If the essay isn't already too long, I'll demonstrate how to gather forced-alignment data using local models such as wav2vec2-latin so I can play audio snippets of Latin texts directly from a transcription buffer in Emacs. Lastly, I want show how to leverage Gemini to automatically create multimedia flash cards in Org mode using the anki-editor Emacs minor mode for sentence mining.

The result is an experiment called fesh. It works strictly as a deterministic pre-processor pipeline wrapping LZMA (xz). The AI kept identifying "structural entropy boundaries" and instructed me to extract near-branches, normalize jump tables, rewrite .eh_frame DWARF pointers to absolute image bases, delta-encode ELF .rela structs with ZigZag mappings, and force column transpositions before compressing them in separated LZMA channels.

Surprisingly, it actually works. The CI strictly verifies that compression is perfectly reversible (bit-for-bit identity match) across 103 Alpine Linux x86_64 packages. According to the benchmarks, it consistently produces smaller payloads than xz -9e --x86 (XZ BCJ), ZSTD, and Brotli across the board—averaging around 6% smaller than maximum XZ BCJ limits.

I honestly have no idea how much of this is genuinely novel versus standard practices in extreme binary packing (like Crinkler/UPX).

Repo: https://github.com/mohsen1/fesh

For those who know this stuff:

Does this architecture have any actual merits for standard distribution formats, or is this just overfitting the LZMA dictionary to Alpine's compiler outputs? I'd love to hear from people who actually understand compression math.

Supports multiple-accounts (track as a family or even as an advisor), multi-currency, a custom sheet/calculator to operate on your accounts (calculate taxes etc) and much more. Most recently, we added support for benchmarking (create custom dashboards tracking nav and value chart of subsets of your portfolio) and US stocks, etfs etc.

We also write about like:

How fund performance explain part of returns, rest is explained by timing. And ways to tease those out: https://finbodhi.com/docs/blog/benchmark-scenarios

Or, understanding double entry account: https://finbodhi.com/docs/understanding-double-entry

https://breaka.club/blog/why-were-building-clubs-for-kids

The recent Netflix Games edition of Overcooked with K-Pop Demon Hunters is cool, but not nearly as cool as kids coding and playing their way through Overcooked levels in our custom educational mod for Overcooked:

https://youtu.be/ITWSL5lTLig

I'm also maintaining GodotJS, strongly typed TypeScript bindings for Godot, which is used to build the Breaka Club RPG (see first link):

https://github.com/godotjs/GodotJS

And last week I also put together the first release of MoonSharp in ~10 years; Lua runtime for Unity. That's not for Breaka Club though, I also consult for Berserk Games on Tabletop Simulator:

https://github.com/moonsharp-devs/moonsharp/releases

https://milliondollarchat.com a reimagining of the million dollar homepage for the AI age. Not useful, but fun. A free to use chatbot that anyone can influence by adding to the context. The chatbot's "thoughts" are streamed to all visitors.

I have some barebones content at https://struggle-meals.wonger.dev/ and will be working on the design over the next few weeks. Some decisions I'm thinking about:

- balancing between personal convenience and brevity vs being potentially useful for other people. E.g. should I tag everything that's vegan/vegetarian/GF/dairyfree/halal/etc? Should I take pictures of everything? (I'd rather not)

- how simple can I make a recipe without ruining it? E.g. can I omit every measurement? should I separate nice-to-have ingredients from critical ingredients? how do I make that look uncomplicated? (Sometimes the worst thing is having too many options)

- if/how to price things? Depends on region, season, discounts, etc

From Agentic Reasoning to Deterministic Scripts: on why AI agents shouldn't reason from scratch on every repeated task, and how execution history could compile into deterministic automations

https://juanpabloaj.com/2026/03/08/from-agentic-reasoning-to...

The silent filter: on cognitive erosion as a quieter, more probable civilizational risk than a catastrophic event

https://juanpabloaj.com/2026/02/27/the-silent-filter/

KPT is a language app specifically targeted at explainable verb conjugation for highly inflected/agglutinative languages. Currently works for Finnish, Ukrainian, Welsh, Turkish and Tamil.

These are really hard languages to learn for most speakers of European languages, particularly English - we're not used to complex verb conjugations, they're hard to memorise and the rules often feel quite arbitrary. Every other conjugation practice app just tells you right/wrong with no explanation, which doesn't really help you learn when there are literally hundreds of rules to get right.

The interesting part was using an LLM to create a complete machine-executable set of conjugation rules, which are optimized for human explainability, and an engine to diagnose which rule is at fault when you get it wrong. There's several hundred rules needed for each language in order to cover all exceptions.

NB as a bonus it also works fully offline because my best practice hours are when I'm travelling and have poor connectivity.

I recently converted a bunch of stuff to be client side instead of server side (turns out running a real-time MMORPG server is expensive) so there's a new round of bugs I'm still resolving, but it's still fun to play:

https://www.idlequest.net/

Over the last year I've been hacking on Table Slayer [0] a web tool for projecting DnD maps on purpose built TV-in-table setups. Right now I'm working on making hardware that supports large format touch displays.

Since I also play boardgames, this past month I threw together Counter Slayer [1], which helps you generate STLs for box game inserts.

Both projects are open source and available on GitHub. I've had fun building software for hobbies that are mostly tactile.

[0]: https://tableslayer.com

[1]: https://counterslayer.com

    const app = new App("com.apple.finder")

    const window = app.$({role: "window"})
    const someButton = window.$(/* another query */)

    someButton.press()

Targeted towards music producers and AI (there's one collection of snippets that starts an MCP server and exposes some basic functionality) in the beginning.

My favorite features are: - custom layout and drag and drop to change window - auto resume to last working session on app starting - notifications - copy and paste images directly to Claude Code/Codex/Gemini CLI - file tree with right click to insert file path to the session directly

OH and it works on both Windows and MacOS! Fully open source too!

https://github.com/oso95/Codirigent

I've wanted this for a long time, so I finally started building it. I've had a lot fun!

- Graph-based signal flow: Products become nodes, connections are edges inferred from port compatibility (digital, analog, phono, speaker-level domains)

- Port profile system: Standardized port definitions (direction, domain, connector, channel mode) enable automatic connection inference

- Rule engine: Pluggable rules check completeness, power matching, phono stage requirements, DAC needs, and more

Give it a try!

This is the kind of project that creates something from as little as possible, where the only things you need to get started are a very basic RISC-V assembler and a computer or emulator to run it on.

I don't have anything interesting to show yet because I just started yesterday, but one day I will show you.

It is a pretty fun project

It's been a ton of fun to work on. Every subsystem is still flaky so I run into the wackiest bugs imaginable. I'm really grateful for the resources[1] and incredible tooling[2] that enable me to work out my frequent mistakes. I can hardly fathom how Torvalds did this with just his PC running Minix!

No idea how long I'll keep working on it. I think I'd be pretty happy if I got a real-world, non-trivial program running on top of it, but in the meantime it is serving as a good distraction from life worries at least :]

[1]: Intel 80386 Reference Manual, Linux man pages, wiki.osdev.org, various datasheets and the occasional query to ChatGPT free tier.

[2]: QEMU+gdb, Bochs, GCC 9 & binutils

I have a fairly novel approach to operating it, and in the case of one time theft prevention security through obscurity is actually a great approach. The assailant only has a short time to pull the car apart and solve the puzzle, couple that with genuine security techniques, a physical aspect, and it should be pretty foolproof.

It can still be towed away, etc, not much to be done there except brute force physical blocks. Most cars get stolen here to do crime in that night so it's not as common.

https://DuoBook.co

It’s like netflix for language, where users can select/create their personal bilangual stories.

I had quite a lot of feedback from HN, friends, random people on the internet and trying to solve the common pain points and find my way around to make it geniunely useful.

- Most people said it’s hard to come up with a story, so I added url grounding. Also added buttons (including HN :)) so people can just click click and get their stories at their level with their interests.

- Made sure people can generate stories without ever signing up

- Each word is highlighted while being read, and the meanings can be checked with a tap. I also added an option for users to read the sentence for being checked how good their pronounciation is.

- Benchmarked 7 different models to get the fastest & highest quality story generation (it’s gemini now) and it’s insanely fast. I might share more about it on the webpage because I am an engineer and I enjoy this stuff lol.

- Added CSV import in Use my words so Anki users can just import their words to study.

- Also people can download their stories as pdf so they can send it to their kindles.

- I am working on a ChatGPT app, so people can just say “@DuoBook give me a Dutch/English story on latest Iranian events” within ChatGPT, but I am a bit afraid that it might be costly lol.

It has been a lot of fun to learn about Vulkan / GLSL and the GPU execution model to figure out why the CPU is so much faster than the GPU. I'll be open sourcing the code soon but so far I'm documenting my journey in a series of blog posts. First one of the series is https://www.execfoo.de/blog/deltastep.html

One thing that I've been very happy with has been "org-people", now on MELPA, which allows contact-management within Emacs via org-mode blocks and properties. It works so well with the native facilities that it's a joy to work on.

I've been learning a lot of new things while I've been expanding it now it has a bigger audience (e.g. "cl-defstruct" was a pleasant surprise).

https://github.com/skx/org-people/

Why? Many yarncrafters painstakingly build spreadsheets, or try to bend existing general purpose pixel editors to their will. It's time consuming & frustrating.

Along the way, I've solved a bunch of problems:

  - Automatic decreases (shapes the hat) / overstitching markers (shows when multiple colors are used in the same row)
  - Parameterized designs, like waves, trees, geometric shapes. No more manually moving an object by a couple of pixels, it's a simple click & drag.
  - Color palette merging (can't delete a color if you already use it in a pattern!)
  - Export to PDF (so you can print it or stick it on a tablet)
  - Repeat previews (visualize the pattern as it repeats horizontally)

If you drag a shape near the right edge of the canvas, you'll see it "wrapping around" onto the right edge.

This reflects the 3D reality of a hat!