https://github.com/dahlend/kete

It can predict the location of the entire catalog of known asteroids to generally within the uncertainty of our knowledge of the orbits. Its core is written in rust, with a python frontend.

Take photos of the tree from 6 different angles, feed into a 3D model generator, erode the model and generate a 3D graph representation of the tree.

The tool suggests which cuts to make and where, given a restricted fall path (e.g. constrained by a neighbors yard on one side).

I create the fallen branches in their final state along the fall plane, and create individual correction vectors mapping them back to their original state, but in an order that does not intersect other branch vectors.

The idea came to me as a particularly difficult tree needed to come down in my friends yard, and we spent hours planning it out. I've already gotten some interest from the tree-surgeon community, I just need to appify it.

Second rendition will treat the problem more as a physics one than a graph one, with some energy-minimisation methods for solving.

https://github.com/scottfalconer/vibedb

I still have no idea if it's a good idea or a bad idea but it's been fun to think through.

I watch a lot of YouTube videos and have found it very annoying that YouTube latches onto one or two topics that you've watched and only recommends that type of content over and over again. Even if you use their "Not Interested" tool, not a whole lot changes in your recommendations.

At the end of last year I launched Relevant - a crowdsourcing website where users can categorize the channels they watch into a defined hierarchy of categories ranging from broad topics like "Science" and "Gaming" to more specific ones like "Phone Reviews" or "Speedrunning".

Although I've had good feedback on the website, engagement has been relatively low and I think that's because it's a big ask to have someone navigate to the website to find the content. This year I decided that I'd bring the content to them by making a Chrome extension that lets users interact with Relevant directly from within YouTube.

It's still a work in progress but I'd love to get a first version out within a month or so to start spreading the idea and gathering feedback. If this is of any interest to the people here on HN then please let me know what you'd like to see most on your feeds.

https://relevant.watch/

On top of that, it uses a lightweight AI model to read product descriptions and filter based on things like ingredients (e.g., flagging peanut butter with BPA by checking every photograph of the plastic or avoiding palm oil by reading the nutrition facts) or brand lists (e.g., only showing WSAVA-compliant dog foods). Still reviewing results manually to catch bad extractions.

Started this to replace a spreadsheet I was keeping for bulk purchases. Slowly adding more automation like alerting on price drops or restocking when under a threshold.

Colibri—a self-hostable web application to manage your (and your family's) ebook library, intended as a companion to Calibre. I want it to be a friendly, simple, capable, opinionated app to review your books, add metadata to them, get them onto your reader, share them with family and (few) friends, create a public shelf for bragging, connect with Goodreads etc., and exchange comments and reviews on books.

This is explicitly not intended to ever be monetised, and I enjoy all the implications that has on the design. Colibri is as much a tool I personally want to use, as it is a study in small-audience user interfaces, and the quest to build the perfect book catalog schema.

I'm looking for fellow book-loving people to work on Colibri, to create the best personal digital library possible. If you're interested, feel free to reach out via email (in bio), or on GitHub.

Right now I'm working on a version 2 that has user accounts, multiple documents, markdown support, and document exports. Everything is local-first and it uses CRDTs to sync documents.

It looks like this: https://i.imgur.com/Plk1DQ4.png the calculator is mostly the same for now, with a few improvements. It's unstable right now, so I don't want to publicise the dev url, but if you'd like to become a beta tester email me at contact@numpad.io

I got diagnosed with type 1 diabetes in Feb (technically LADA as it's late onset). I'm the first in my family with it so I had zero info on it. I tried getting some CGMs to use but most don't work in Kenya as they are geo-locked, and even apps for measuring carbs like CalorieKing are not available in my region. I was really frustrated with the tech ecosystem, and started working on My Sukari as a platform of free tools for diabetics.

I mostly get time to work on it on the weekends, so it's not yet ready for public use, but I've fully fleshed out one of the main features: Sugar Dashboard - A dashboard that visualises your Glucose data and helps you easier analyse it.

To help with demos, I've shared my Sugar Dashboard here: https://mysukari.com/tools/sugar-dashboard/peter

I'm really passionate about this and getting as much free, practical tools in the hands of patients (it honestly shouldn't be this hard to manage a disease)

Also, a visual programming language implemented as a PICO-8 script, where the "programming" is done fully in the sprite editor.

You can search for full or partial rows and see the whole query lineage – which intermediate rows from which CTEs/subqueries contributed to the result you're searching for.

Entirely offline & no usage of AI. Free in-browser version (using PGLite WASM), paid desktop version.

No website yet, here's a 5 minute showcase (skip to middle): https://www.loom.com/share/c03b57fa61fc4c509b1e2134e53b70dd

- there are lots of expenses still to be made (fertilizer, pesticide, salaries), which may not be worth it if germination is under certain threshold

- if detected early, there is still time to plant another grain or to fill up the missing plants (requires precision seeders and seeding maps)

- is a very good proxy for yield estimation (farmers often trade futures even before they have harvested)

For the purpose I have created a dataset (a collaboration between my employer and Sofia University) and published it in order to enable scientific collaboration with other interested parties. Still working on the dataset annotations.

https://huggingface.co/datasets/su-fmi/sunflower-density-est...

Instead of masonry I would like to work on time of flight cameras. But the day has only 24 hours :-(

https://github.com/abhchand/simplee-food

I found most of the offerings out there to be too bloated. Recipes are a simple thing - you want to store them, search them, and view them easily.

It has a full screen viewing mode for easy cooking with your tablet or phone.

I've only built it for Minneapolis and Chicago for now.

https://mplscoffee.com

I hit an OpenSearch bug this week where you can't get any browser based requests to work. Its due to zstd becoming a standard part of Accept-Encoding and OpenSearch not correctly supporting it so I wanted to install a browser plugin that modified the browser HTTP request headers to my servers.

I don't know about everyone else but I love that browser plugins are possible but I hate having to find them. Its mostly due to never knowing if you can trust a plugin and even if you find one, you have to worry about it being bought out in the future. With vibe coding I was able to build a browser extension in 45 minutes that had more features than I originally planned for.

I spend more time documenting the experience than building which is wild. If you are interesting you can look at the README in https://github.com/mattheimer/vibe-headers

But I left the experience with two thoughts.

Even seasoned developers will be using vibe coding in the future.

I think in the near future the browser plugin market will partially collapse because eventually browsers will build extensions themselves on the fly using natural language.

input a relevant url, it will decide if it IMDB or Youtube or a list. using an llm, it will attempt to extract the movies or series from the list and find the relevant IMDB link.

Then I have a masonry view of movies & series I have and have not watched, sortable by tags that I can rate and add notes to.

So despite not being a programmer, barely knowing a little javascript, and nothing about python, linux, or gtk, I was able to use AI to muddle my way through to creating a program that takes the input from a numpad, looks up the song from a list, sends it to mpd, and posts a picture from the album art embedded in the music file. https://github.com/jccalhoun/mpcButtonJukebox

So most of my project work is home-based, after years of being able to chase (and execute) dreams at work.

On the technology front, I'm finally investing in a proper network core for home. WiFi 7 AP, 2.5Gig core, PoE everywhere, zone-based firewall. Still mapping out DHCP scopes and VLANs, but once that's done it'll be moving on to proper IoT and Home Assistant build-outs to prepare for the Unfolded Circle 3 later this summer. Also looking to redo my two N100 hypervisors off Proxmox and back to RHEL + Cockpit, or some other Linux + KVM implementation; from there, it's all about Kubernetes, Ansible, and Terraform. Really just a lot of oft-postponed side projects because I had amazing fulfillment at work, that I suddenly have ample time for now.

Outside of the tech stuff, I'm still trying to get some decent photos of two local birds of prey that have been hunting in my neighborhood. They seemingly spite me by only showing themselves when I don't have my camera with me, but dangit, I will photograph them.

On the writing front, I've got a few topics jostling around in drafts: speculating on potential futures of LLMs, the internet as a psychohazard, and a series of "fundamentals" to try and teach my non-techie circles more about how computers and the internet work, so they can do some modest self-hosting and get off centralized services. I'll likely dovetail some of them with my own home projects, writing them alongside the documentation as I make progress.

If it strikes a chord with anyone, I’d love to collaborate! The concept is centered around organization bubbling up naturally from dumping info in with tags, and “typing” your tags so that when you go to a tag’s page, the layout is customized based on what it is - a project, person, etc. A project could have all relevant tasks and notes listed, whereas a person might have name, contact info, etc.

https://github.com/weakphish/yapper

As a freelance web dev who also has an Airbnb side hustle, I got tired of expensive bookkeeping for a few transactions per month. I tried DIY, but my time is worth more than that.

Most importantly, both pros and DIY got subtle things wrong and caused me to miss out on thousands of dollars in deductions and credits.

So I’m making an AI bookkeeping chatbot that will handle all that for me. The aim is full automation while surfacing tax deduction and credit opportunities throughout the year. Like wouldn’t it be awesome to just have the research and tax credit or do home office deductions with zero effort?

At the end of the year, Kumbara puts together a series of financial reports that you plug into your tax software or hand to your CPA.

Working hand-in-hand with CPAs and some platform partners on this. Would love to hear from other solopreneurs or engineers who want to help build the future of financial freedom.

https://www.kumbara.money

In what I believe is still the spirit of the question though, I discovered Maltese these week and have added it to my casual study. It’s a Semitic language (closely related to Arabic), written in the latin script, with about 40-50% of its vocabulary being Italian/Sicilian based. It’s become my new obsession

Been a freelance dev for years, now going on "sabbatical" (love that word) imminently. Just moved to reduced hours, still in the transition and unwinding phase.

Planning to do a lot of learning, self-improvement, and projects. Tech-related and not. Preparing for the next volume (not chapter) of life. Refactoring, if you like, among other things.

I'm excited.

Yes, customer is a special snowflake but they still need 90% or whatever every other client in this industry needs.

Feeling increasingly like this is a fools errand.

Even though we've proved this out with tool sets strung together with duct tape and safety pins, and are therefore the most profitable group within our department, we still need to be 100% billable.

It's only because we're the most profitable group that we can pretend we're all billable while I work with two other people to bootstrap this crazy project

Edit: anyone hiring? Just found out my boss is quitting.

Here’s a a detailed write up of the process: https://samkhawase.com/blog/hacking-kindle/

I've been building PodSnacks because I found it overwhelming to keep up with podcasts across tech, business, and science. PodSnacks uses LLMs to summarize the most popular episodes from shows like Lex Fridman, Acquired, All-In, Invest Like the Best, and more.

You choose your favorite shows, and we email you short, high-signal summaries — no audio to skim through, no endless backlog guilt.

So far:

126K+ episode summaries generated 92K+ hours of podcasts processed 48–50% open rates 2,900+ early users

Still iterating and adding features like bundling by theme, language translations, and audio feeds.

If you're the kind of person who wants more inputs without more noise — would love for you to check it out.

Always open to feedback from HN!

You provide a PDF and a JSON schema defining what to extract, and it returns the extracted values, the citations and their precise locations in the document.

This is especially valuable in workflows where verification of LLM extracted information is critical (e.g. legal and finance). It can handle complex layouts like multiple columns, tables and also scanned documents.

Planning to offer this both as an API and a self-hosted option for organizations with strict data privacy requirements.

Screenshot: https://superdocs.io/highlight.png

Feel free to get in touch for a demo.

I vibe coded the above including everything: code, design, logos. Just did it solo. It has all error handling, video generation notifications (it takes a while) and credit system. I myself can't believe it's been done in a month with AI. It's already in closed beta in iOS and android app stores. Let me know if you want to try it out before public release.

My quoted comment above was 28 days ago. This is working on this part time and with a family.

EDIT: Added context.

This is one of my long-standing passion projects, a simple web-based music sequencer built to have a very low barrier to entry.

I've explored all existing commercially available solutions and none match my requirements/standards (high-quality audio codec/DAC, USB-PD, steering wheel controls, no splicing or cutting into the loom, no cutting up the dash, etc.).

After researching how the Toyota/Lexus infotainment systems work I found they are highly modular, and actually quite easy to produce custom modules for. The proprietary AVC-LAN protocol is well-understood, and actually makes it really easy to integrate with. The display are just NTSC composite, and touch events (in fact, all button presses, including steering wheel media controls) are emitted on the AVC-LAN bus.

An simple board with some interfacing logic, a DAC and an RPi nano should be all I need to allow good Bluetooth audio integration, and lossless audio via wired USB, both controllable from the steering wheel. You could do all sorts of fun things with the display (such as displaying vehicle status from ODB, lap timer, G-force meter etc.). If I use a RPi compute module then running Android Auto should be quite feasible.

It's just a hobby project though, I'll probably open-source everything. Not planning on commercializing it.

The new one is browser based.

The mud engine runs in a web worker and takes advantage of some of the modern web tricks to do stuff. For instance, data files (think: area files that don't change often) can be stored remotely and then cached with a service worker. This allows the MUD to run offline. But that's only fun if you're playing solo.

IO between the UI and worker is handled by message passing.

Multiplayer is handled by the MUD opening an outbound connection (probably websocket) to a connection collector host. Other players would then connect to that host and have their IO routed appropriately. The host can even be smarter: it could be a specialized Discord client, allowing users to play from there. Firebase may also be involved. I don't know.

The important bit is that this is still basically message passing, so the engine won't need to know the difference between the local user and a remote user.

The MUD database would be an IndexedDB. Probably. I haven't thought as much about that yet.

I am sure all of this is theoretically possible, at least.

https://cluesbysam.com

These cloud flavours have a compatible SQL dialect, but it's often details like missing features (CDC and Auditing on RDS are good examples) or differences in system objects that make it difficult to support your app on these platforms.

I capture all sql statements, run them through multiple SQL parsers to find all the system objects your app is using (tables, functions, stored procedures, etc). I then check them all against a catalog I have built of all system objects for every version of SQL Server on every platform.

I then give a report to see which platforms your app will work on, which ones it wont work on and which system objects are the problem.

Other database engines will be added once I get it working end to end (almost there).

[0]: https://ezb.io/thoughts/interaction_nets/lambda_calculus/202...

I think sales will bifurcate: either fully automated self-sale, or fully relationship based. All of the major CRMs (customer relationship management) software are going all in on AI and sales automation.

I think relationship sales is going to see an increase in comparative advantage. I've always been a relationship seller but the current crop of CRMs are not designed for me. So I've built https://humancrm.io/ to scratch my own itch.

If you’ve used H3 or S2 it should be familiar, the major difference (apart from the fact it uses pentagons) is that the cell areas are practically uniform, whereas alternative systems have a variance of around 2 between the largest and smallest cells, making them less useful for aggregation. The site has many visual demos, e.g. https://a5geo.org/examples/area

The code is open source: https://github.com/felixpalmer/a5

My current plan is to test the counting with people with good rhythm sense and once I find a good algo for beat detection I'll proceed with writing the app.

https://github.com/ammmir/sandboxer

It may not be useful, but it's been fun, and I've honed my gut-level experience in Docker, Podman, Linux namespaces, Checkpoint/Restore, CRIU, and more. The ultimate goal is to hand each AI agent iteration a sandbox of its own (forked from the previous iteration), and have it build apps in private sandboxes. You'll be able to view intermediate progress as the app is being built (or failed rabbit holes), since each sandbox gets a unique URL automatically. Like, imagine if each commit of your git repo had its own URL to preview the app!

[1] https://amirmalik.net/2025/03/07/code-sandboxes-for-llm-ai-a...

At a very early prototyping phase, but having a ton of fun. https://x.com/artofpongfu

So far I have ~ 3M distinct IP addresses per 30 days, with a lot of fresh proxy IPs, 1.7M. The DB contains only verified IP addresses through which I've been able to route traffic. It DOESN'T rely on 3rd party/open-source data sources.

I also made an open-source proxy IP block list based on the data: https://github.com/antoinevastel/avastel-bot-ips-lists

In parallel, I'm building an exercise generator "Jazzln" [2] to help me practice.

[1]: https://www.goodreads.com/book/show/54391815-jazz-harmony

[2]: https://jazzln.vercel.app

Personally I'm having fun learning some web design and three.js as I try to debug the very tricky issues with my new personal website loufe.ca using AI is fantastic but you need to micromanage when things get complicated, I find.

https://my.adminix.app/demo

If you like what you see please let me know, all feedback is appreciated

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

[2] https://news.ycombinator.com/item?id=43654350

7 months ago, I was looking for a job and got frustrated with the current resume builders, so decided to build one exactly how I wanted a resume builder to be.

- Free (like really free).

- No signup, no login.

- Has AI features to improve text.

- Find jobs matching the resume.

https://resumeyay.com

A simple puzzle game: a cassette-futuristic story, heavily inspired by Nell’s adventures at Castle Turing in Neal Stephenson’s “The Diamond Age”.

I could go on and on...

I’d love your feedback:

Rewind to the start of the story: https://magiegame.com/test/2025/04/04

Or skip to today’s puzzle: https://magiegame.com

Right now I’m focused on story development and integrating it with the daily-puzzle system I built last time I was between jobs.

This is a years-long slow-burn side project. My career moved away from the frontend long ago—this is my first React app, with a Django backend running on AWS Lightsail.

https://github.com/wantbuild/want

https://doc.wantbuild.io

Want is a hermetic build system, configured with Jsonnet. In Want, build steps are functions from filesystem snapshots, to filesystem snapshots. Want calls these immutable snapshots Trees. Build steps range from simple filesystem manipulation and filtering, to WebAssembly and AMD64 VMs.

You can read an intro here: https://blog.tangled.sh/intro (it’s publicly available now, not invite-only).

In short, at the core of Tangled is what we call “knots”; they’re lightweight, headless servers that serve up your git repository, and the contents viewed and collaborated upon via the “app view” at tangled.sh. All social data (issues, comments, PRs, other repo metadata) is stored “on-proto”—in your AT Protocol PDS.

We just shipped our pull requests feature (read more here: https://blog.tangled.sh/pulls) along with interdiffs and format-patch support! https://bsky.app/profile/tangled.sh/post/3lne7a4eb522g

We’ve also got a Discord now: https://chat.tangled.sh — come hang!

The idea is simple: a job search site that actually works for job seekers. It focuses on listings posted directly by companies (no spam, no middlemen, no bloated sponsored posts drowning out real opportunities). It uses AI to surface better matches, recommend jobs intelligently, and pull out the most important info from job listings automatically. You can also bookmark jobs you’re interested in and track them easily — no signup needed unless you want personalized suggestions.

It’s still early, and we’re improving it constantly. Would love for you to check it out, try a search, and let me know what you think — good, bad, rough — all feedback helps. Thanks a lot for the early support!

Site: https://jobswithgpt.com

Escape rooms are honestly... almost always a let down but the concept has a lot of potential and there are some really neat ones that standout like this local one where you pilot an airship https://www.portlandescaperooms.com/steampunk-airship

Once I build the best escape room on the planet, I can consider selling the tools.

https://trilogydata.dev/trilogy-studio-core/

https://tallytabby.com: The simplest way to keep track of anything in your life. From habits to inventory, TallyTabby makes counting effortless.

https://qrfeedback.app: Get honest customer feedback with a simple QR code

https://skillriskaudit.com: Knowledge Risk Management

https://shiftingtictactoe.com: The classic game with a twist—play in real-time, and there’s never a draw!

The book is written in the Choose Your Own Adventure style. Readers get to join the protagonist Daphne on a fun, week-long adventure launching her own mini-businesses. Readers help her make smart decisions, solve fun challenges, and learn about money and problem-solving in the process.

The book has been a fun endeavor in both writing the manuscript and code! On the latter, I wrote an exporter for Twinery to Org Mode and an Emacs Org export backend to do the reverse.

The book is currently open to beta readers - Happy to let a few more in through the sign up page here: https://tendollaradventure.com/#get-notified

  - XRoll.io — a fully on-chain gaming framework on the XRP Ledger, inspired by SatoshiDice but built for compliance. Commit-reveal fairness (HMAC_SHA256(secret, bet_txn_hash)), full transparency on-chain. Integrated KYC, AML, self-limits at the protocol level. Frontend is optional; ledger is the source of truth.

  - Nexula — an evolutionary image generation system. Embeddings extracted with CLIP, clustered via HDBSCAN, visualized with UMAP. User behavior (time spent) drives fitness scores; top samples recombine through weighted interpolation to generate new images. Built on Django backend, session-based personalization without login.

I also just today made a fun way to fully host a front end and SQLite back-end on GitHub for free using Pages + Actions, you can try it right now: https://do-say-go.github.io/fully-hosted/

https://snot-22.linsomniac.com/

https://joeldare.com/how-to-lose-money-with-25-years-of-fail...

I've created a mailing list. Please sign-up if seeing all my new business tries is something you might be interested in.

https://tally.so/r/wvggOX

https://www.exploravention.com/products/askarch/

It is an interesting discovery journey on extracting relevant information from both code and documentation with a sufficient density to stay within the context window and extracting efficient criteria from arbitrarily phrased questions.

Building this for myself mainly, but hoping others might find it useful. Still very early and building out the bear essentials, but then the hope is to keep reading marketing books and use that to improve the platform.

- Snapshot (https://apps.shopify.com/snapshot): AI generated product photos for Shopify. Previously used Flux and Stable Diffusion but always had quality problems. Was very tricky ensuring text remained the same and the product fit into the generated background. Just integrated the new OpenAI image generation model and results are much better however their masking feature doesn't work properly so need to wait for them to fix that before I can offer the same feature of keeping text/fine details the same

- Lurk (https://apps.shopify.com/lurk): New one I just launched - allows Shopify merchants to track the prices of competitors and adjust their own in response with dynamic pricing rules. It's cool because you just have to paste a URL and it uses AI to figure out the price. Again, there's a surprising amount of things you need to figure out to make this work reliably at scale (e.g. popups, ambiguous HTML, location-based pricing, etc.)

- Origin UTM Tracking (https://apps.shopify.com/origin-utm-tracking): Simple UTM analytics for Shopify stores. Acquired this last year and its being growing nicely.

Crucially, to make this bound work, you only learn the final state of the heap, not which element got deleted when.

I'm also building a simpler soft heap.

https://www.stainedglassatlas.com

e.g.

"san francisco ca united states" - San Francisco, California, America

"california, san francisco" - San Francisco, California, America

"glasgow, kentucky" - Glasgow, Kentucky, America

"glasgow, UK" - Glasgow, Scotland, United Kingdom

It started as a project when I was scraping websites, and some data had inconsistent ways of writing a location or address.

The library is called location4j - https://github.com/tomaytotomato/location4j

https://mini2-photo-editor.netlify.app to try it out (https://github.com/xdadda/mini-photo-editor)

I am purposefully not doing chain loading or multi-stage to see how much I can squeeze out of 510bytes.

It comes with a file system, a shell, and a simple process management. Enough to write non-trivial guest applications, like a text editor. It's a lot of fun!

Not quite done with it yet, but you can see the progress here https://github.com/shikaan/OSle and even test it out in the browser https://shikaan.github.io/OSle/

[1] https://shikaan.github.io/assembly/x86/guide/2024/09/08/x86-...

Pretty anxious about that, given how massive of a life change it is, and how much will be riding on me getting good grades.

I wrote this tool to make instrumenting language servers very easy. MCP (both protocol and architecture) seems heavily inspired by LSP which made me curious about what it would take to support it through my telemetry-capturing proxy.

Haven't thought too deeply about how useful an MCP proxy can be but I see it as potentially a general platform for monitoring or debugging MCP servers or clients.

I'm a member of the JSON Schema Technical Steering Committee, and been making a living consulting with companies making use of JSON Schema at large. Think data domains in the fintech industry, big OpenAPI specs, API Governance programs, etc. The tooling to support all of these use cases was terrible (non-compliant, half-baked, lack of advanced features, etc), and I've been trying to fix that. Some highlights include:

- An open-source JSON Schema CLI (https://github.com/sourcemeta/jsonschema) with lots of features for managing large schema ontologies (like a schema test runner, linter, etc)

- Blaze (https://github.com/sourcemeta/blaze), a high-performance JSON Schema C++ compiler/validator, proven to be in average at least 10x faster than others while retaining a 100% compliance score. For API Gateways and some high-throughput financial use cases

- Learn JSON Schema (https://www.learnjsonschema.com/2020-12/), becoming the de-facto documentation site for JSON Schema. >15k visits a month

Right now I'm trying to consolidate a lot of the things I built into a "JSON Schema Registry" self-hosted micro-service that you can just provision your schemas to (from a git repo) and it will do all of the heavy lifting for you, including rich API access to do a lot of schema related operations. Still in alpha (and largely undocumented!), but working hard to transition some of the custom projects I did for various orgs to use this micro-service long term.

As a schema and open-source nerd, I'm working on my dream job :)

I'm not doing this because I'm convinced it's a great idea, or because it's going to revolutionize computing, or because it will be a good language, model or beneficial in any particular way, I'm doing it because I think it's fun, neat and interesting to think about (and talk about).

https://heliographe.net

A few released apps for now that are iOS/macOS, with some exciting more things in the pipeline.

If you’re a photographer who has frustrations with current mainstream photography software (whether capture/edit/publishing), I’d also love to hear from you - you can find me as Héliographe on (mastodon,bluesky,threads,x) or just email me at contact@heliographe.net :)

[1] https://github.com/connet-dev/connet

[2] https://connet.dev

Feedback appreciated - https://proxymock.io/

Benefits of SDFs over the standard Boundary Representation (used in Freecad and similar) are that you can do "pattern" operations with domain repetition, which means making N copies of a feature is O(1), vs O(N^2), you can deform objects with domain deformation, which means if you have a closed-form representation of how you want to deform space you can basically directly apply that to your object, procedural surface texturing is easy, CSG operations are easy.

The big drawback is that it is hard to provide any workflow based around "selecting" faces, edges, or vertices, because you don't naturally have any representation for these things, they are emergent from the model's SDF.

I have some blog posts on my progress: https://incoherency.co.uk/blog/stories/sdf-thoughts.html and https://incoherency.co.uk/blog/stories/frep-cad-building-blo...

I am solving the "selecting faces" problem by having the SDF propagate surface ids as well as distances. So the result of the evaluation is not just the distance to the nearest point on the surface, but the id of the specific surface that is nearest.

My next big frontier is reliably providing fillets and chamfers between arbitrary surfaces. I have a handful of partial solutions but nothing complete yet.

The most promising idea is one that o3 came up with called "masked clones", the idea is roughly to make a clone of the 2 surfaces you want to blend, mask them by intersecting with an object that is like a "pipe" along the intersection of the 2 surfaces, apply the blend within the pipe, and then add this "blend pipe" as another child of the lowest common ancestor of the 2 blended surfaces.

And after that I need to work on more standard CAD stuff like constraint solving in the 2d sketch editor.

In the process of adding stuff like euclydian sequences, and trying to figure out how to generate melodies. Been considering using something like a simple markov probability from a bunch of jazz standards, but also starting to read more music theory behind it.

It's a programming project but it's directly related to me trying to figure out music. So not a random sequence of notes in scale or not. The idea is more to generate backing tracks or song starters.

(Pre-launch [https://www.sevenbaton.com] would welcome feedback from marketing folks)

After working on it for a while, I noticed there’s a stigma around using CORS proxies, often associated with fetching undocumented APIs.

While that’s sometimes true, I’m hoping to change that perception, to show that they can also be used for accessing real APIs. It just requires the proxy to correctly handle credentials and secrets.

The idea is to open up more possibilities for building static-first apps without worrying about CORS.

Primarily uses Claude Sonnet 3.7 and Gemini Pro 2.5. But you can choose other models too.

You can try it for free while I'm beta testing it here: https://lumosbuilder.com?ref=hn

I realized after trying multiple tools like Supabase and Firebase, I really need to program my own solution. I don't need a bunch of *Enterprise* level features. I just need to read the card data from a database, and process the games with some simple server side code.

I hope to have the server, along with a basic front end done by this summer. Then it'll be released under a permissible license. Probably MIT.

I want a community of different front ends compatible with the same server. I suspect a straight up cli client without a bunch of effects might be popular with some of y'all.

If you want to code a frontend in Unreal, the server doesn't care. The game remains the same.

Of course your free to fork it privately, build a commerical product, etc.

this was spurred from group texts with friends planning a vacation or outing. we would just throw a bunch of dates that would get lost in the mix and people would forget who was open on what dates. Whenish just allows user to select dates they are free and then it will show what is the best date that works for everyone.

i have a testflight right now and if anyone wants to give it a go please do! i would love feedback :)

https://testflight.apple.com/join/4HaADNMF

ps: i am not a designer and app icons are hard

I’ve done my share of programming languages (PHP, C++, Python, Ruby, Haskell) and for the last 10 years I’ve been working in OCaml (which I love so much) but Rust would be a nice addition IMO.

And I never implemented LSM style database before! So that’s fun.

I only just started and the pace will be slow (I have 3h/week to spend on it on a good week), if you are curious: https://github.com/happyfellow-one/crab-bucket

My primary goal is to make a game that's fun. Secondary goal is to make you experience why an AI might do things you don't expect. Specifically, to further instrumental goals like collecting resources, refusing being turned off, things of that nature.

There are two endings currently but I'm working on adding some more.

I'll have a working project in about a month. But for now it's just a readme.

I have revived my work on Go Micro (https://github.com/micro/go-micro) and rewritten the v5 cli/api from scratch (https://github.com/micro/micro). As a VC funded company there was a lot of confusion around the tools we were building and we veered off in a direction that alienated the community. With the company dead, funding gone, etc there's an opportunity to rebuild value around the Go Micro framework.

The second thing I'm working on is the Reminder (https://reminder.dev && https://github.com/asim/reminder). As a muslim I feel like it's my duty to spread the word of Islam and as an engineer I feel like an appropriate way to do that is build an app and API for the Quran, names of Allah and hadith. It's a slow patient building of something as opposed to expecting anything from it.

In terms of new ideas, maybe not new but less screen time, less phones, more nature.

Over the past few weekends, I’ve been building Pantry Recipes – a mobile app that lets you quickly generate recipe ideas based on the ingredients you already have at home.

The idea is simple:

- Save or quickly select ingredients you have on hand - Tap Generate Recipes and get ideas instantly - You can also describe what you want to make free-form (e.g., "cheese omelette") and the app will generate a recipe for you.

The app is free for a number of recipe generations, then offers a low-cost subscription if you want unlimited use. It's live on the iOS App Store now: https://apps.apple.com/us/app/pantry-recipes/id6744589753

Happy to answer any questions if anyone’s curious about the tech, UX challenges, or what I learned from launching!

This thread made me realize I've made no progress in acquiring new clients since posting about this 6 months ago. However, my part-time job ends in May, which will allow me to focus exclusively on Fanfare. It's somewhat intimidating, but I'm also looking forward to it; the prospect of resolving this uncertain situation (either through success or failure) feels liberating.

[^0]: https://www.withfanfare.com/

The idea is you can set a few filters (like bpm, key, decade, genre) and then swipe through random songs, accept or reject them for inspiration or playlists. Kinda like Tinder but for digging through your own tracks.

It also tracks what's trending on TikTok/YouTube/SoundCloud weekly, so you can find stuff that’s blowing up, filterable by region. Plus it can build smart playlists automatically based on rules you set (like “new 90s house under 120bpm” every month).

It is just a tool to make working with your existing local/Apple/Spotify/SoundCloud library faster and more creative.

Here's a demo of it: https://filtered-f.web.app/

It's the first original piece of content for a newsletter of curated gaming content that I've been running for more than five years now, called The Gaming Pub [2].

[1]: https://www.thegamingpub.com/features/ [2]: https://www.thegamingpub.com/

This makes it possible to create a kind of requirement "programming language" where the requirements can be evaluated. With this language it becomes possible to create cross-references from various compliance standards/frameworks, like ISO27K, to USM, and automatically evaluate the compliance.

(2) Dance event calendar in Finland, running in production for over a year. 1-2M page views/month. Django app, but I am now implementing a copy of the unauthenticated user views to S3 bucket and delivering it through Cloudflare.

(3) Django app to handle all the data related to custody trial. Emails, SMS, notes, official records, voice memos, etc. can be attached to a timeline, and tagge and searchable. It has command line interface for adding data, in addition to UI, so I can quickly add notes and attach files.

[1]: https://www.philliprhodes.name

While Kubernetes offers power at the cost of complexity, Uncloud focuses on simplicity for common deployment workflows.

Progress from this month:

  - Enhanced Docker Compose support: You can now deploy your entire stack from standard Docker Compose files. This includes volumes, environment variables, resource limits, scaling and logging configuration.
  - Volume management: Create and manage Docker volumes across your cluster with automatic scheduling based on volume location.
  - Context management: CLI command to quickly switch between multiple clusters, e.g. homelab and production one

If you're seeking something between "just Docker" and full Kubernetes for deploying applications on your own infrastructure, I'd love to get your feedback on Uncloud.

[1]: https://github.com/psviderski/uncloud

A Markdown-first CMS and website builder for blogs, newsletters and documentation websites.

I've been blogging since more than 10 years, and the only thing that made it possible is Markdown. That's why I've decided to build a complete publishing platform to replace the complex and fragile setups of bloggers and startups. Do you really need a CI/CD pipeline, static site builder, hosting, CDN and analytics just for a website? :/

The platform is currently 100% operational and I'm now working to Open Source it.

The best thing? You can publish directly from the CLI:

$ mdninja publish

I've got an LTE module connected to a solenoid lock. The module listens for a "checkout complete" callback from a Stripe payment link which will unlock the solenoid. There's also some weight sensing involved to track the current product inventory inside the cabinet.

I built this for a family friend who does a lot of wellness outreach around combating food deserts by introducing small scale farming to local schools.

As a result of their community bee hives, they have a bunch of excess honey. So, I thought I’d build them this little honey vending cabinet for their neighborhood.

I've expanded the service a bit to be more product agnostic, maybe someone else can find a use for it.

I've trained martial arts for a few years, and have always been that person who tries to introduce those close to me to the community. I know a lot of other people do the same.

Now, I don't care that I wasn't rewarded for it, but why not? We have point-based programs for nearly everything. Why not for martial arts as well?

* Have a few academies in the process of testing it out. Still a lot to do, including the demo video that isn't going to load on the main page.

It lets you create multiple agents, configure them via the web console (such as LLM parameters and system prompts) and manage their plugins and functionality.

The system is fully plugin-based, where each plugin is a WASM program that exposes functions/tools that the agent can call, and can also hook into the query lifecycle. Because plugins are WASM, they can be written in various languages such as Rust, Go, TypeScript etc. Plugins can also act as libraries, which is possible because of WebAssembly Components (a great piece of software!) -- so you can dynamically call functions from other plugins within your agent, and you get type support for your chosen language too (with codegen via WASM Components tooling).

More recently, I've been working on an SSH server for agents. The idea is that you can add public keys to your custom agent and then SSH into it to talk to it easily from terminal.

If this sounds interesting, feel free to join our Discord! The project is still new and feedback is highly appreciated. http://asterai.io/discord

This is why I'm building a unified MCP server with just two meta tools: - Search Available tools - Execute a tool

When I want to send an email, I ask LLM to use the Search Meta tool to search for Gmail related tools in the backend, then the meta tool returns the description of relevant tools. The LLM then uses the Execute meta tool to actually use the gmail tool returned. https://github.com/aipotheosis-labs/aci

What they are. their capabilities, and their and risks and write about it on my Substack

Encyclopedia Autonomica: https://jdsemrau.substack.com

On that note, I also curate a list of resources around AI Agents that fit my narrative:

https://github.com/jsemrau/Agent-Repository

Soon I'll start work on Lua bindings. The idea is to configure the core engine programmatically. Hook up inputs, modify synth parameters, route output. It's going to be inferior in every way to something like SuperCollider, but I just think it'll be insanely cool to materialize music from thin air. I've learned lots.

1. While I can share source code and documentation with trustworthy people, that won't work at scale: the market would get flooded with Chinese clones that re-use my Open Source software but then I have no ongoing revenue to fund support / maintenance.

2. Especially for products with a physical component, shipping, taxes, refunds, CC chargebacks etc. add considerable overhead. Plus I need to add in Amazon fees and marketing spend. And suddenly I need to charge 8x the manufacturing price, which means I either need to massively cheapen out with quality, or it's going to be a very premium product.

I also published the list of url schemes / universal links on GitHub: http://github.com/sxp-studio/app-list-catalog

Whispers is a self-organizing, belief-driven mesh where nodes propose, verify, and evolve solutions through dynamic, decentralized consensus.

Basically a shared knowledge graph of proposed partial inferences in CRDTs using verification as a merge function. There're some issues I know I'll run into with e.g. admissibility but I have some solutions in mind.

I'm in the very early stages but I think it's a simple idea so I have high hopes for a cool demo soon.

I honestly hate it at this point and would appreciate any reading on the topic. It's been a grueling 4 months of back and forth with a lot of mission critical business aspects to handle that I had to learn on the fly.

You can drag and drop links from YouTube, Twitch, TikTok, or Kick --and they show up in a grid.

You can reload or remove streams without refreshing, save mixes for later, and share them as links. It works best on a really big screen --phones aren't really supported and even notebooks are too small to get much benefit.

There's no backend, no login --everything runs in the browser.

https://panoptic.live/

We use data from club & sponsor to measure conversion over time. Our challenge lies in attributing a select group of people who appear in both datasets. Sponsors spend millions on their sponsorship, and they have no idea what comes back.

We also got funded last week & looking for a founding engineer (2nd employee) :)

https://wehavenotes.notion.site/backend-engineer-aws-python

https://injee.codeberg.page/

I’ve been doing tedious manual entry for a bit over two years now and after having missed three consecutive months, the only other option was to bail.

As a start it should help with 3 main things:

- Translation, categorization: my source documents aren’t in English but my GnuCash entries are. This is one of the reasons I don’t use the built-in imports. (This should shave off at least 90% of time spent entering data)

- Human-error prevention: there were at least 5 times where it took me over 15 minutes to reconcile a discrepancy because I entered some number or some account wrong somewhere.

so you can get logos / icons that doesn’t look AI generated.

it comes with Photoshop-like editor (https://mitte.ai/editor) so you can zoom into details and change / remove anything, or upscale, etc.

I built it for myself but now there’s good amount of paying users as well.

https://medium.com/@DougDonohoe/ce45d56c8773

Writing well is hard and takes time. Was it Mark Twain that said "If I had more time, I would have written a shorter letter."? I can totally relate to that this month. Getting your point across without being long winded is challenging.

https://github.com/mcp-router/mcp-router

Works with VSCode, Cursor, Cline and any MCP client, and connects to servers from any registry (Zapier, Smithy, etc.).

My main motivation was to implement a service that publishes the addresses of containers and vms that I run on my workstation to my local network, but it gradually has grown into a full-blown implementation of RFC 6762, which has been fun.

https://chromewebstore.google.com/detail/unpack/mcgdbnjjnnfm...

Fil-C is a memory-safe implementation of C.

https://github.com/pizlonator/llvm-project-deluge/blob/delug...

You can try it easily on Linux/X86_64:

https://github.com/pizlonator/llvm-project-deluge/releases

If you’re tired of bloated to-do and note-taking apps, give this a try. It's OSS, free and No sign-up.

Basically looking to clone laracasts.

If I can't find one, that is what I'll be working on.

https://github.com/kenrick95/ikuyo

So far it has some sort of activity calendar + expense tracker

There's still so much ideas to implement, like adding map, improve UX of creating activities, to-do list, etc

I've used it once or twice of a short trip, but in 6 months time, I'll have a 2-weeks trip, so that's my self-imposed "deadline" for this project

Anyway this project is a pure static web page and all the 'back-end' is handled by InstantDB ( https://www.instantdb.com/ ) after I saw their submission on HN >.< So far it has been quite a good experience overall except maybe the permissions model which can be a bit confusing to me

On the "side projects" side of things, I've been working on a "boot to EndBASIC" disk image since December with the goal of creating a small "dev kit" box that boots quickly and directly into the interpreter. The disk image is pretty much done for a first release, so now I need to get to the design and 3D-printing of a case for the board+screen combo. The latter is brand new territory for me, and I have a self-imposed deadline of June when I'll be presenting this at BSDCan.

... but I've also taken a small detour to improve the EndBASIC website and provide a dynamically-generated gallery of user-uploaded projects. This has been a deficiency for a while and I felt it'd be easy to add it, right on time for the "dev kit" release.

Stay tuned!

https://www.confabulists.com

The experience with GitHub can be terribly frustrating when it comes to managing the stream of incoming pull requests. The default inbox and notification systems are not so good, and not flexible. Critic allows to create any number of sections, each section being defined by an arbitrary search query.

I would now like to expand it to provide a better code review experience, similar to what Graphite or Reviewable may provide - but under as an open source project. Source code is available at: https://github.com/pvcnt/critic

It’s a small vending machine on the internet where people anonymously send a friend three postcards, one word at a time. The first two cards are unsigned, and the last one reveals who sent them. It’s meant to be a slow, kind surprise in the mail.

I shared this on HN a while back, and it gave us a quiet little push. Since then, we’ve sent 246 out of the 300 postcards we set out to deliver this year. Things have slowed down lately, but the whole thing is automated, costs almost nothing to run, and has been a lot of fun to work on!

I work a lot with smaller investors, in real estate, private money lending, etc. It's sometimes hard to do due diligence on someone, and after having a couple bad deals and realize over 30 people were scammed, I wished there was a simple review site where you could see someone's past reviews.

Site is 80% there, hoping to enter beta in the next month.

My goal is to create games on the go, during my commutes.

It's a fork of https://lowresnx.inutilis.com/, there is some videos of my progress on https://www.youtube.com/playlist?list=PLtmKVaz_2Cxe6pG7VbQfw... and a Discord channel https://discord.gg/jcT9CXDgHB

It's inspired by VS Code and hopefully positioned to eventually be a Cursor-like experience for transactional lawyers. The LLM integration isn't baked in yet to keep the in-house onboarding frictionless.

It's a desktop application written in Rust. It uses egui (an immediate mode UI library) for speed.

I'd greatly appreciate any comments.

- As you're reading, AI helps you with words it thinks you might not know

- Highlights etymologies & mnemonics

- Shows you words in their natural habitat, e.g. listen to example sentences

https://www.hellozenno.com/

I'm trying to read a kid's version of The Odyssey in Greek and to be able to understand my partner's mum, and these are the features that I wanted.

Also, I wanted to experiment with "what would an app like this look like if we could trust AI to be very cheap/fast/correct?".

- So, for example, it's a fully generative dictionary & search, e.g. the dictionary entries/metadata/example sentences don't exist until the first person searches for them!

- You can upload any kind of content (image, audio, text), and it'll automatically transcribe, translate, annotate, etc.

Produces a pick order that shifts as the draft progresses.

Have a browser runnable colab notebook for 20+ sets.

https://github.com/danieljbrooks/statistical-drafting

We're currently working with language influencers to build courses on Emurse. This year, we launched Japanese Phonetics course created by the YouTuber Dogen https://emurse.io/course/japanese-phonetics.

If you want to try out Emurse, we have a free Thai reading course available. You can view the first lesson without out creating an account: https://emurse.io/courses.

RSS readers show content based on the feed they're coming from, and show read and unread items in the same list. That makes it difficult to know which items you've already seen, and is especially annoying for managing items that you want to read at some point but not anytime soon.

Lighthouse splits it into Inbox (new items) and Library (bookmarked items). This makes it possible to process new items quickly, and take your time with reading them.

It started when I found it surprisingly hard for my partner to install and connect MCP Servers — even simple ones. I realised if we want AI agents to really interact with the web, it needs to be as easy as installing an app.

Right now, you can browse, install, and connect servers in one click. Over time, it’ll make AI integrations as easy as installing an app — no messy APIs, no custom scraping.

If you’re working with AI models, agents, or data-heavy tools, I’d love to hear what kinds of “context pipes” you’d want to see added.

[1] - https://depth-anything-v2.github.io/

I'd love for you to try it out! It is browser based only for now and pretty basic. I'm adding features sparingly as needed but my next task is to add some documentation for brand new users and making what it can already do more obvious.

www.fableflops.com

MITM + Waydroid doc: https://github.com/ddxv/mobile-network-traffic

Actual scraper (look in adscrawler/apks/waydroid.py): https://github.com/ddxv/adscrawler

Final product of reporting for which apps talk to which country / companies will go on: https://appgoblin.info

Feel free to contact me if you're interested in learning more.

Currently working on a solidity upgrade for a leader-board, and public analytics.

D-Safe for children, adults and plants. I am looking for contributors to integrate it on https://internet-in-a-box.org .

No worries, I'll do it myself if everyone is busy.

https://datapond.earth

Email: data at datapond.earth

Some things I'm planning on including: - App drag & drop for assignment. - Programmable macro buttons. - Small OLED displays to show app icon and volume levels.

Attempting to do everything in Rust too, even the MCU firmware. It's been a lot of fun. xD

It sends me an email once a story hits a certain number of upvotes per minute, so it's useful for keeping track of breaking news.

https://hnalerts.com

It has these capabilities for now : - Prebid flooring insights ( uses an LLM to generate a summary )

- screenshot at various times

- real time console logs

- Prebid detection

Hoping to share a first version of it soon. It’s been absolutely fascinating digging into Postgres internals!

https://github.com/bsubard/Godot-3D-Procedural-Infinite-Terr...

I’ve been working on it for a few months and I’m hoping to have a demo up at 7:00 PST today for HN to play with :)

It's compatible with Settlers of Catan. However, I plan to make my own rulesets, artwork, manuals, etc. It will not be a commercial product, of course you can make your own with the files I provide.

Right now the boards, electronics, and firmware are in good working order. Although the routing is pretty YOLO.

It feels like there's a lot of unpleasantness going on in the world right now. I thought maybe I could put my other projects aside and try to make something that might brighten your day (It certainly has enough of LEDs).

A big TODO is to replace the 0402 SMT components with something larger and easier to work with like 0603. I'll find time within a week or so and push it to the repo. (I am notoriously cheap and only keep 0402 in stock)

A few examples of what it can currently do:

- Automated data backup: Listens for Nomad job events and spawns auxiliary jobs to back up data from services like PostgreSQL or Redis to your storage backend based on job meta tags. The provider for this is not limited to backups, as it allows users to define their custom job and ACL templates, and expected tags. So it can potentially run anything based on the job registration and de-registration events.

- Cross-namespace service discovery: Provides a lightweight DNS server that acts as a single source of truth for services across all namespaces, solving Nomad's limitation of namespace-bound services. Works as a drop-in resolver for HAProxy, Nginx, etc.

- Event-driven task execution: Allows defining custom actions triggered by specific Nomad events; perfect for file transfers, notifications, or kicking off dependent processes without manual intervention. This provider takes in a user-defined shell script and executes it as a nomad job based on any nomad event trigger the user defines in the configuration.

Damon uses a provider-based architecture, making it extensible for different use cases. You can define your own providers with custom tags, job templates, and event triggers. There's also go-plugin support (though not recommended for production) for runtime extension.

I built this to eliminate the mundane operational tasks our team kept putting off. It's already saving us significant time and reducing gruntwork in our clusters.

Check out the repository[1] if you're interested in automating your Nomad operations. I'd love to hear your thoughts or answer any questions about implementation or potential use cases!

[1]: https://github.com/Thunderbottom/damon

(Thoughts welcome!)

Nice to do something just for myself

I started experimenting and I think this builds out pretty neat estimations from jira tickets/other descriptions. When I was sitting in the CTO role, I spent a ton of time talking with people about how long/short various projects would be. When I was a developer, I hated the estimation piece because it felt like it was both keeping me from building and was almost never done with enough context to get really accurate results.

I was playing with the OpenAI API and I noticed that they can actually return a set of probability x next tokens and I thought that it might actually give you kind of cool ways to see the distribution of potential outcomes. (You can see an example here: https://universalestimator.com/estimates/c68db45b-7622-4bab-... that looks at a detailed ticket for implementing filtering on a dashboard.)

Let me know if you have any feedback, it's free with the promo code TYHN. If you run into any issues, please send me an email at earl@unbrandedsoftware.com

    anubis_policy_results{action="CHALLENGE",rule="bot/lies-browser-but-http-1.1"} 3891

My current goal is to spend half of my time on the development and maintenance of open source projects, such as Glicol (https://glicol.org/).

The other half of my time is to do some business that can generate profit from day 1.

I just found that the VC model is not suitable for my current situation.

Yet my problem really arises that its too luck based, sometimes I can be the last guy, Sometimes I can be the first guy so I have to wait for the van to get fully occupied which will take a lot of time...

I have just made it, and I find it pretty nifty, I made it all completely via AI and this one absolutely crazy good youtube video on deploying telegram bots on cloudflare...

Also, I had seen this telegram bot ai maker idea on HN a few days ago, So I had also created a project which you can chat with the microsoft deepseek r1 post training bot for free because the api key of open router for this model is free, It doesn't have incremental streaming or multi chats, really basic, and It can generate me the code but I am not sure how I would deploy that code .. , I used to think its easy but not... ,any resources out there? (Though I want to open source this, but I am not going to be building this ai idea further because I lack time and I have to study)

I’ve been building https://lowlow.bot, it tracks price changes on any website. I was inspired by https://camelcamelcamel.com, but wanted something that worked for more than just Amazon. It’s been handy for big purchases I’m ok waiting for and stocking up on recurring non-perishable essentials when they go on sale. It also lets me know when something has come back in stock.

https://github.com/RickCarlino/KoalaCards

My main challenge has been making meeting detection more robust -- it currently uses both mic and camera activity, which led to a lot of false positives. In the next version I’m switching to mic only (the camera caused most of the noise) and I’ve added a way to identify which app is using the mic, so users can exclude non-meeting apps.

I’ve also added plenty of small tweaks throughout to make LookAway even less interruptive. I’m excited for the next release!

https://github.com/turbolytics/sql-flow

I think the industry lacks lightweight fully featured stream processing solutions. I think it’s either heavyweight jvm or bespoke custom solutions

Sqlflow aims to be a middle ground , performant, fully featured, observable and supports sql

https://calendarforynab.com

Any feedback is welcome!

I once saw an idea on here[1] about putting a lot more historical information into a calendar, including past activities. It resonated with me and I wondered if bank transactions could be part of this activity layer. At the time I was working on a real-time integration between my bank and YNAB so I was already thinking about the space.

1: https://julian.digital/2023/07/06/multi-layered-calendars/

It works well but copying/pasting back and forth gets old very fast, and it would be better if the process was done inside the word processor. For some reason (various reasons) I still use Office 2003, which doesn't have any AI feature. (It does have a "translate" function but it's awkward to use and not very good.)

So I wrote a macro to send selected text to OpenRouter and replace with the response (with a system prompt that says to only output the translation, otherwise most models start with "Here's the translated text:")

I had never written a macro in vba; I got started with Sonnet and adjusted many parts with the help of StackOverflow (which turns out to have more information about vba than Sonnet...)

And finally it worked; and it turns out to be an incredible boost to translation productivity!

I love exploring data, but it always felt clunky to juggle multiple tools, write code/commads, just to import and query a dataset. While there are multiple GUI tools for databases, none are focused on raw data.

TextQuery is the tool I built to solve that. You can import CSV, JSON, and XLSX files and start querying them instantly using SQL. Want to create a chart? Just hop over to the Visualize tab.

I'm also rolling out a major update this week — adding tabs, filters, a redesigned UI, and keyboard shortcuts.

Looking ahead, I’m planning to expand support for more formats (like Parquet and ORC) and data sources (like Postgres and BigQuery), so you can import data from anywhere, and query it right from your desktop. Something like a local data warehouse. With Apple Silicon, the capability of a desktop can make it very cost-efficient compared to something like BigQuery, Snowflake, or Athena.

Happy to hear any feedback!

I'm also working on and off on a hardware device for blind people.

So far all my work has gone into the technical side of setting up the game (a Java app written in 2010) to work as a reinforcement learning environment. The developers were nice enough to maintain the source and open it to the community, so I patched the client/server to be controllable through protobuf messages. So far, I can:

- Record games between humans. I also wrote a kind of janky replay viewer [1] that probably only makes sense to people who play the game already. (Before, the game didn't have any recording feature.)

- Define bots with pytorch/python and run them in offline training mode. (The game runs relatively quickly, like 8 gameplay minutes / realtime second.)

- Run my python-defined bots online versus human players. (Just managed to get this working today.)

It took a bunch of messing around with the Java source to get this far, and I haven't even really started on the reinforcement learning part yet. Hopefully I can start on that soon.

This game (https://planeball.com) is really unique, and I'm excited to produce a reinforcement learning environment that other people can play with easily. Thinking about how you might build bots for this game was one of the problems that made me interested in artificial intelligence 8 years ago. The controls/mechanics are pretty simple and it's relatively easy to make bots that beat new players---basically just don't crash into obstacles, don't stall out, conserve your energy, and shoot when you will deal damage---but good human players do a lot of complicated intuitive decision-making.

[1] http://altistats.com/viewer/?f=4b020f28-af0b-4aa0-96be-a73f0... (Press h for help on controls. Planes will "jump around" when they're not close to the objective---the server sends limited information on planes that are outside the field of vision of the client, but my recording viewer displays the whole map.)

https://github.com/codr7/hacktical-c

Also learning to deal with having very little to no money atm.

It has integrated BIN inventories from Afternic, Sedo, Namecheap, Porkbun, and Gname.

Currently working on custom price alerts and an API.

https://johnscolaro.xyz/projects/so-you-think-you-know-brisb...

I'm working on expanding it to all large cities in Queensland, moving it to its own domain, and monetizing it to cover hosting costs.

On the way, I developed lightweight image editor and 3D model viewer components, which I've open sourced [1].

[1]: https://github.com/kigun-org/

My current side project is a vulnerability scanner for binaries. I do VR in my day job, so im trying to figure out how useful (or not) AI is for this domain.

Jury is still out. Getting false positives and negatives, but I can find some known CVEs!

Performance is rock solid, and it’s almost ready to release, I just need to tweak a few things (like free trial with no CC).

I have a very long to do list, and ultimately want to extend it with “change detection”, e.g. notify when an HTML element on a website changes.

All feedback is welcome

https://feedsync.net

4 years ago I made an install script that worked for Debian, Ubuntu and macOS. This made it easier to get going with them.

Over the last week or so I extended and polished that script to make it even easier and customizable, including adding Arch Linux support. The next step is to start installing and configuring GUI tools instead of only focusing on command line tools and environments.

I just used it the other day to set up a fresh work laptop in 5 minutes. Given the script is idempotent I run it all the time on my personal box.

Reactivity can update the state of the notebook automatically, so you don't have to keep track of which cells to execute again. Side effects are managed to make it easier to reason about while maintaining reactivity and ability to interact with the outside world.

No app required!

We took all of the complexity of issuing MIFARE DESFire enabled NFC credentials and made it extremely developer friendly. SDKs in most major languages (python, ruby, csharp, js, etc), developer console with request logs, and more.

the process of creating APIs for testing and automation should be as easy possible. the tools that exist nowadays for this purpose aren't good enough IMHO, which led me to build it.

Onsite deployment is a lot more difficult to make slick and easy. We've been thinking about the best way for our customers to deploy while reducing the load on our support team. So far, we are thinking about RPM's, Debs and Docker and trying to make this as close to a '5 step process' as possible.

I would love to hear people's thoughts on other mechanisms that make it easier for SRM's / DevOps to manage key platform infrastructure software.

I don't expect to place competitively but I learn a lot from these competitions. I like competitions like this that are connected to physical problems and datasets (though sadly this one is largely simulated), I learn as much about the broader world as I do deep learning. I've always idly wondered how seismology worked, and now I have an excuse to dig into it.

It's also given me a greater appreciation for the "seismology" we perform in our day to day, like knocking on things to see if they're hollow, or (as I learned here a while back) the way battitores test the porosity of cheese by knocking on it with hammers.

Since my third year in medical school, I've built the largest medical education platform in MENAP. 90k+ users, 100m+ questions solved, billions of seconds spent learning across our Super App. Now working on sustainably scaling further, building medGPT.

It's awesome, exciting and impactful work. I am the first medical doctor + full stack technologist in Pakistan (250m) people, and we've helped the country move medical education decades forward.

https://github.com/TirrenoTechnologies/tirreno

It gives you a ranked list so you can quickly spot the strongest candidates, or at least get a solid starting point without reading every resume manually.

It scores applicants based on job requirements, flags any concerns, and suggests interview questions you might want to ask.

With 16x Eval, you can manage your prompts, contexts, and models in one place, locally on your machine, and test out different combinations and use cases with a few clicks.

Talo makes it easy to add systems that traditionally need extra non-gameplay build time like authentication, player analytics and game stats.

Right now you can drop Talo into your game or use the API directly. Importantly, I’ve made Talo easy to self-host and you can point the Unity package/Godot plugin to your own Talo instance.

My wife and I are fans, but their Finland-Swedish Vörå dialect is not easy to understand, especially for us in the very south of Sweden. I have watched the recording too many times to count, and made these so she could enjoy it more.

2. Basecoat, a HTML/CSS port of shadcn/ui v4 [2] (no React).

3. DevPu.sh, a Vercel for Python apps.

Releasing both Basecoat this week and DevPu.sh hopefully in the next 2 weeks.

[1]: https://github.com/pages-cms/pages-cms

[2]: https://ui.shadcn.com/docs/tailwind-v4

It's a bottom-to-top rewrite of a timer app that I've had in the App Store since about 2012. This is probably the fourth rewrite.

[0] https://github.com/RiftValleySoftware/ambiamara/tree/master/...

https://heymeta.com

Also revisited and updated Let's see, an eye trainer, which is basically a PWA you can "install" on your tablet/mobile/e-reader. I'm not a scientist, but have had some success training my eyes with this technique and wanted to make a simple app that I can share with my friends to try.

https://letssee.publicspace.co/

Any feedback welcome :)

https://invoicepilot.net/

It's my fun little project to resort to. Implemented dark mode, sorting, grouping and various layout improvements. Also added a Drawer with Auction view the other week. UI is finally fun again with component libraries and LLMs.

Oh, and I added a Cloud Server Availability [2] page as I noticed people on /r/hetzner were complaining about lack of resources. Looks like their Cloud offerings are going quite well.

[1] https://radar.iodev.org/ [2] https://radar.iodev.org/cloud-status

https://github.com/ncruces/go-sqlite3/tree/main/sqlite3/libc

The idea is that growth becomes a lot more intentional when you can reflect daily, set goals clearly, and get structured input from people you trust — all in one place instead of scattered across different tools.

I'm getting ready to open early access soon. Curious if others have tried combining these areas or if you use separate tools for goals, journaling, and feedback!

https://proflect.io

Much cheaper to hire a VPS with attached local storage, than to use an external database and a lot quicker too.

Notably not an AI agent like Operator, Manus, etc. which are largely unreliable for the time being. Instead this uses AI to turn your task into something repeatable and configurable.

Currently focusing on scraping use cases but hope to make it more powerful soon so it can actually do complex tasks rather than just extracting data.

Everything will be bound to a key in the spirit of VIm :-)

I don't have a landing page yet, but if this sounds interesting to you, you can sign up here: https://lindon.app

I'd also love to hear what would be important to you in an application like that.

Basically it continuously records into a buffer (length is configurable), and if you realize that you wanted to start recording 30 minutes ago you can recall the buffer and have everything saved.

In my work and an audio engineer I was in this situation a couple of times, and since there was no tool for that on the market, I’m building it.

You might ask why use Pocketbase at all, and I'm not sure anymore. I suppose the dashboard is great, built in auth is great (although I've had to write cookie middleware to make it SSR anyway). I wish there was a lightweight Pocketbase/Supabase style "backend in a box" setup that didn't push the whole client library directly communicating to DB paradigm.

Key features: - Multi-website management with single sign-on (one dashboard for all sites) - Static rendering via Cloudflare KV for 100% uptime and blazing speed - Real-time editor with AI-powered automated internal backlinks - Theme switching without breaking functionality

We're currently serving 100+ websites. It's completely free for non-profits.

Would love feedback from anyone managing multiple content sites!

I wanted a library to store my own prompts once and retrieve it in multiple locations (i.e. Try something on claude desktop and then once I wrinkle out the edges, load it in Roo code or claude code and use it.) Give some variables to the prompt and creating infinite versions of same prompt by providing the value. Or having the versions of each prompt.

Currently I have the landing page, soon (In max 10 days) I will make it live for everyone to use.

Slowly building an open-source Data Lakehouse management utility application for local development, scratching my own itch and trying to accelerate development workflows with customers developing for Databricks.

For now it only supports Delta Lake (using delta-rs + duckdb), only supports table metadata inspection and querying, but in the near future will add dashboards as code, simple Markdown notebook like mode, and Apache Iceberg support.

For now it's an enabler for me and others, hopefully I can turn it into a product somehow at some point.

Website allows you chat with all github repository.

https://www.mydebugtools.com/

https://medium.com/@level09/build-the-future-an-ai-powered-n...

Had to implement the bindings first, because js.Value kind of sucks. Meanwhile I am building web components and widgets and it's slowly getting where I want it to be.

Maybe after a couple more weeks I can finally build apps in 100% Go and together with webview/webview. Still needs a lot of work around the edges here and there.

[1] https://github.com/cookiengineer/gooey

I spent a long time working in manufacturing and struggled to find a piece of software where we could define a process, share instructions and collect data all in one go.

The idea is you can basically turn your process into an interactive flowchart and follow it through. I’m almost code complete on the MVP, moving into distribution mode in a few weeks.

I’d love to hear from any HNers who’ve gone from 0 to 1 on a SaaS for non technical users. What worked for you?

e.g.: Following up on one of my HN comments on OpenAI ImageGen gpt-image-1 quality: Side by side comparison of more challenging prompts at Low/Medium/High:

https://generative-ai.review/2025/04/apple-a-dog-how-quality...

It's still a work in progress, but it's already functional if you want to try it out. I'm keeping it super lightweight, clean, and focused just on writing without the usual bloat.

Basiclaly an app where you can travel a city on a hex grid (h3) and learn about it/receive recommendations on things to do. Different activities and landmarks are hooked into language learning games, which when completed, add phrases/words to a flashcard deck for future study.

I was tired of all the ads, and the poor formating on recipe websites.

So I made a website to import food recipes from any location (text, YouTube, file...).

It has been fun so far! I tried importing from fb/ig by using a meta app but it has been a horrible experience so I scrapped that ^^

Terminals are tragically under powered as well as hostile towards beginners! We're moving the needle there.

[0] https://terminal.click

Which one? We are figuring this out.

Regardless of if I target macOS or Linux first, this would be a pretty full time endeavour on my part. I could wait until the commercial use licenses of the Windows version sustain me enough to be able to work on this full time, or try to raise a Kickstarter for $X00,000 to be able to quit my 9-5 and work on porting full time for a year or so

[1]: https://github.com/LGUG2Z/komorebi

Plus, implementing encryption for https://github.com/mattrighetti/envelope

Let me know if you have any feedback or feature requests.

https://bsky.app/profile/arcadenest-games.bsky.social

https://orbiter.host

1. Eli5 equations(2) uses an LLM to convert a given picture of an equation to latex and, if given additional context, breaks down the equation parts to explain it. Gemini for the model.

2. reflecta - a journal prompting app with deepseek to help reword and target the prompts towards you better.

(1) https://arkaine.dev

(2) https://eli5equation.com

(3) https://reflecta.hlfshell.ai

It works like a run club, where you have to make a review first to see other people's reviews.

I am currently implementing watchlists, comments and a mural to make it feel a bit less lonely. Right now I like the UI but it feels to lonely.

[1] https://scrtwpns.com/mixbox.pdf

SaaS - I'm working on this mostly marketing that tech.. harder than it looks am I right? https://prfrmhq.com - see https://news.ycombinator.com/item?id=43538744 [Show HN: My SaaS for performance reviews setting goals and driving success]

- Shows I can use AI and I've integrated into AWS Bedrock

- Shows I can integrate with Stripe for payments

Consulting (Architecture, Strategy, Tech) - I'm working on getting my consultancy started. If anyone wants the kind of skills I offer here let’s talk https://architectfwd.com

Next SaaS - Starting a SaaS for managing core strategy and tech concepts. I created goals for it but I’m failing to kick the tyres

Last night I actually also started playing with firebase studio, though the app I prompted isn’t even doing save of the document properly. I figure can’t be me but will try again and work through the errors.

And playing drums, must get better

[1] https://dedede.de/en

We're based in Kyoto and the posts are heavily Japan-centric; we'd love to see posts from all over the world!

I am working on an open-source insurance application platform.

The main goal is to accelarate time-to-market for insurance and insurtech innovations, providing all these "boring" enterprise features (like multitenancy, role-based security, audit trails, etc.) out of the box, so that you can focus on building the actual product.

Private recipe archiving/bookmarking. No ads, no AI, no javascript . Join a server or host your own (https://github.com/bradly/recipin).

Bacon Wrapped Urns- https://baconwrappedurns.com

Mortality is so hot right now so why not celebrate with a custom urn to enjoy your journey into the spirit world in style.

Been prod for a few months, recently ripping through 900TB with ~5x efficiency (customer was on BigQuery).

If anyone has any data/infra challenges, or just wanna talk about this kind of tech, lemme know :D

I'm giving myself 18 months- it's been super fun so far!

PostScript has two mechanisms to save and restore the machine state and they are intertwined and only vaguely documented. I'm trying to get my head around all that this week.

Sounds basic, and it is, but I've yet to find any open source project (let alone product) that does this.

All I want to tap a button, talk to the little guy about how to update my document, and see the changes flow. I guess Claude projects or similar might do this but I'm making it more for friends and family. Current use case is keeping track of a house renovation project going on.

Key features:

• Built-in speaker and LED for alerts

• Preloaded with 66,000+ known speed camera locations (more to come)

• Easy updates via drag-and-drop on your PC

It’s been a fun project to build, and I’m excited to see it help drivers stay away from speeding tickets while keeping their data private.

I’d love to hear your thoughts or suggestions!

I’m still looking for a new SaaS idea, so if you have something you want to partner on do reach out. Preferably Rails or Go. Previously I built stuff like https://getbirdfeeder.com/

A free French alternative to Google maps. Soon European.

A prompt collection platform that let's you organize your prompts, share them, learn prompts from other users and reuse them on multiple LLM / AI platforms. It's aimed at improving prompt engineering skills for both technical and non technical LLM users. Currently in Alpha phase and actively looking for feedback.

I may also finally finish implementing WebMentions support too as a kind of comment section.

I may also work some more on my long-term relaxation/creative maze generation and solver project.

At work, I keep putting off yet more refactorings that are required because of poor/missing requirements and non-technical leadership of the project.

It wouldn't be so bad, but part of this "new" project involves communicating with some awful SharePoint """database""", as well as a poorly designed real database (it has multiple values in one column, not even with any standard, just sometimes there's extra numbers I need to parse, sometimes not - just lots of this type of crap repeated everywhere), and the worst development/deployment experience I've ever had to deal with in ~10 years.

To write code involves Remote desktop to what was a single core VM (and much protesting gained me... one extra core) to Windows Server 2016 meaning most modern/nice developer tooling isn't supported, and deployments are all done by copy pasting files over yet more nested remote desktop sessions.

Sadly there's no real way of automating any of this, every suggestion is always a "default no", again most of the tools I'd need for this won't run on Windows Server 2016, and even if I worked around it the stakes are way too high for "It's easier to ask forgiveness than it is to get permission".

The turn around time for even a small change is huge because of this mental burden, it's a complete slog to get anything done.

So I guess what I'm saying is I've been casually looking around at jobs this month.

This is why I always stress the importance of being able to work on my own projects, because otherwise, I'd have burnt out.

/rant

Currently I have decided that I can add "Email" as source, to be able to read not only news, but emails in my app.

Official release is Cinco de Mayo, I'm very excited!

https://www.boot.dev

1 - https://onlyhumanhub.com

The idea is to build scanning databases, file systems, buckets, etc. for static keys and credentials while allowing users to add new file types and parsers.

[1] https://github.com/adaptive-scale/blacklight

It’s currently in beta for macOS but I’m waiting for Anthropic to extend my rate-limits before I announce it here on HN.

https://nelly.is

It'd be cool if you were on the same branch as somebody else, or another device, and your working directories could be synced. It'd also be cool for the commit history to be a bit richer, so you could see who, what and when for a change at a keystroke level.

So I'm working on real-time sync for Git! I'd represent the working directory as a tree CRDT [1] and sync that through FUSE and p2p networking.

Not sure whether this is actually a good idea! This is a POC :)

[1] https://martin.kleppmann.com/papers/move-op.pdf

It's an website who's goal is to make it easier to find apartments/hotels/etc that fit your housing preferences (starting with places that are close to the people and things you care about). It's flagship feature is the ability to make heatmaps of cities based on your preferences.

Since February I've slowed down on feature development temporarily as I try and find a way to sustainably increase it's popularity and learn what's the most important thing to focus on next.

There is some small improvements to make but I want to focus on onboarding via a sandbox environment first next month.

What I'd love to be working on: Try to initiate a high voltage arc through the air to a target device, and modulate it to send "Data over Lightning", like Alyx does in Half-Life 2. It won't work the way it does in the game, but I'd it's an idea I've had for a long time and I'd love to prototype it some day.

The first is a preventive maintenance and calibration tracker (https://pmcal.net) that was born out of my day job as an engineer in small business manufacturing.

The second is an AI engine for pulling structured data out of incoming email (either via IMAP on your email server or via SES). If you think of the engine that powers TripIt, they had to write about 10,000 different ingestors for each airline and hotel and travel booking site. With a structured output AI, the need to write specific ingestors goes away.

I would like to create a sort of search engine for that.

Nothing fancy or innovative, but just to learn Golang in a bigger context.

I'm trying to capture a sense of fun, wonder and connection through these tools which I feel has been lost in recent times with remote working.

It only stores (timestamped) floating point values with a series id and uses a B+Tree as the backing data structure. Querying is done with a lisp-like query language.

just waitlist for now, but I have posted some demos on my twitter - https://x.com/rogutkuba/status/1915533678207262931 - https://x.com/rogutkuba/status/1915226139812839690

docs:https://arkflow-rs.com/

Also working out the logistics of offering a microgrant to award people who want to make movies like this!

So I started making a simple roguelike and an engine for a browser game. Nothing fancy but entertaining.

which enables you to debug faster with error optimization.

you can join our community from website. https://www.almightty.org/

The only self-hosted option I found was wger.de and while it looks great, it's a bit too much for my needs. I want something lightweight (so as not to hog resources on my cheap VPS) that does what it needs to do and nothing more.

It's been a while since I've done web dev, so I'm going to try out Deno (TypeScript) with htmx.

A merge conflict resolution tool integrated with GitHub. Now working on a solution for preemptive conflict detection and a smarter/simpler merge queue.

https://zacusca.net

Open-source differentiable geometric optics in PyTorch.

https://closer.so

basically a user give an initial prompt ie "create a game" and then a series of ai (gemini, openai, claude) prompt themselves until a finished outcome. the user can change any output step in between so the end result can be tuned instead at any point

So far this has means orchestrating a set of processes just to talk to bluetoothd, automatically connect to boards, guess which /dev/input/event* device each one is associated with, and start reading those and sending data somewhere over OSC. Every step of the process is about 10 times as difficult as I initially expected it would be, which is why, after months of work, I'm still putzing around with process orchestration instead of actually doing anything with music.

The bit of hair on this yak that I'm currently shaving is building a TUI library for Deno so that I can build a nice dashboard for keeping tabs on the state of all the different pieces. I prototyped a bit of the orchestration process in Node-RED, which was neat, but not exactly what I'm going for. There is a TUI library for Deno already, but it's kind of buggy and non-ergonomic for my brain.

It has hierarchical clustering, rolling correlation charts, a minimap, time series data detrending, and 2D matrix virtualization (to render only visible cells to the DOM).

It has up to 130K matrix cells and correlates up to 23.5M time series data points.

https://covary.xyz

Next feature is search.

Launch soon! Drop a comment if you want early access

It's in a functional state, I use it myself but it needs some more ergonomic features before I'd suggest for someone else to use it.

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

https://theorium.org/constraints.html

https://aiconstrux.com

I'm curious: what are your must-haves in a note-taking application?

https://agentscode.dev

Building a tool to supercharge your Cursor, Windsurf, Claude and other developer tools by connecting it to polished, high quality mcp servers for linear, slack, DBs, and other useful workflows.

https://github.com/CakeCrusher/self_improving_agents

thinking about taking dancing lessons instead, maybe afrobeats.

Linux skills? Just the basics: cd, ls, mkdir, touch. Nothing too fancy.

As things got more complex, I found myself constantly copy-pasting terminal commands from ChatGPT without really understanding them.

So I built a tiny, offline Linux tutor:

  - Runs locally with Phi-2 (2.7B model, textbook training)
  - Uses MiniLM embeddings to vectorize Linux textbooks and TLDR examples
  - Stores everything in a local ChromaDB vector store
  - When I run a command, it fetches relevant knowledge and feeds it into Phi-2 for a clear explanation.

Full build story + repo here: https://www.rafaelviana.io/posts/linux-tutor

Think multi-generational family and asset data. Everything in common formats, written in simple code.

Looking for early customers or modest pre-seed investment.

Collecting the data helps with recording engine performance, tyre ages, best lap times but is also really useful for recalling how well each setup performed for future reference.

I’m deliberately doing this all in a very low-tech way as my son will be creating a more polished version for a school project. We’re front-running that a bit to give him a good dataset and explore various ideas.

On that note, they do Python in school. For the backend it will be SqlLite and Flask. Any suggestions for the front end tech? This will mostly be forms- and grids-based so nothing sophisticated needed, but some simple client-side logic (e.g. validation, geolocation, simple stop watch) would be good. Ideally this would be python as well. We could use WebAssembly but am wondering if there is a suitable framework that does the is out-of-the-box.

Jobless and no prospects ... Working on a couple projects at once.

Pictures at the link. There's also some webtoys on there, feel free to peruse

https://lmao.center/babble/

I know, it sounds crazy.

In a month or so, I’ll be sharing some news.

There are already a few services like this, but most don't support using a parent's voice, and very few can connect stories together into a continuous narrative based on previous ones. Also I would like to hold context for fairy tales kinda local. For example Polish folklore is different than British. Most common villains are different and it can be fun and educating problem to solve.

I'm mainly doing this as a learning project, but curious to see where it ends up.

The smallest (in terms of system calls and code) event sourcing database I can make.

Being more present.

https://carimbo.run/

Also still working on a custom Slicer for a special metal printer design. The VTK library version needed replaced by a simpler Blender Geometry nodes solution to extract texture information, and infill hull features.

Also considered a beautiful solution to Roger Penrose's Andromeda paradox. That guy has a wicked sense of humor... very funny. =3

And an example video is here: https://youtu.be/1duE604MGHs

It definitely has not gotten the traction I'd expected, but at the very least I'm very close to start making my own courses with it!

It's a performance analytics platform for runners who love to dive into the details after they've been for a run and to be able to accurately track their progress over time.

It's not like Strava because I'm not including any social elements, intitally. And not like trainingpeaks because it's focused on individuals as opposed to teams or coaches. Also the analytics and models I offer are peronalised as opposed to one-size-fits-all. It's also running only. No cycling or anything else.

Ideal target market would be fairly decent amateur runners (e.g. sub 3 hour marathoners) who already know quite a bit about training but don't have a coach and are not good enough to be pro and have a full team doing this stuff for them. The pros have awesome tools but sadly most are not available for us mere mortals BUT I can build some of them! Example features:

1. Personalised "adjusted speed" models. The strava GAP model doesn't fit very well for me and many others, so I've made my own personalised model which gets updated each week. If you get better/worse at running up hills then model adjustments take that into account. The idea is not to provide a physiological correct model but more a performance based one.

2. I'm trying to do the same for surface types, heat and humidity as well. Of course these models are not personalised. I'll get to wind later on as it's much more complicated than the former. The idea is to have an accurate representation of "effort pace", which you can use as an input to performance models.

3. Using adjused pace data I will offer a pace/duration model to estimate critical speed/LT1/LT2/VO2max and this model forms the basis of tracking progress over time. Clearly most training wont be all out efforts, so I also estimate race performances based upon current fitness as well. E.g. if you ran X speed for Y time at a sub maximal effort then you can estimate what a maximal effort would be based upon the remaining aerobic and anaerobic power. From reading sports science literure, this is the most advanced way to track performance at the moment. The actual model I use is called an omniduration model.

4. I also have build some other models, e.g. Daniels running formula, which can be used but I don't find them to be as useful as the omniduration model.

5. I'm also trying to model how a workout or training session will effect your fitness. Where it's base/aerobic, threshold, VO2max or an anaerobic effect. Then, the idea would be to look at future training performance to assess whether the model was correct. You can then assess which types of training you respnd best to as well as which types of sessions you need to get the performance gains you need for your next race.

6. Specific race time predictor. Most platforms offer a single figure prediction for a distance but I want to offer specific race perdictions which take the course and weather into account. The model will give you splits taking all this into account.

7. Cohort adjusted performance models. How are you tracking against people your age? But more importantly, how are you tracking against people doing a similar volume and type of training to you? Are you improving at a similar rate?

There's a tonne of other stuff I can add but I'm going to keep it simple and focus on performance modelling for now because no-one seems to offer any decent tools around this at the moment.

If anyone found this interesting then I'd love to hear any feedback - let me know. Cheers!

https://reader.manabi.io

Currently working on adding a manga mode and Netflix auto-captioning

https://gouach.com

I am also working on the last few remaining issues of Hyvector, of which some are surprisingly difficult to solve and AI unfortunately cannot help me a lot.

https://goodspeech.chat

It’s not launched yet officially, only friends and family so far!

Any feedback is welcome!

for (int i = 0; i < 10000; ++i) renderWindow.draw(sf::Sprite{/* ... */});

Upstream SFML: - 10000 draw calls (!) - My fork: 1 draw call

This (opinionated) fork of SFML also supports many other changes:

- Modern OpenGL and first-class support for Emscripten - Batching system to render 500k+ objects in one draw call - New audio API supporting multiple simultaneous devices - Enhanced API safety at compile-time - Flexible design approach over strict OOP principles - Built-in SFML::ImGui module - Lightning fast compilation time - Minimal run-time debug mode overhead - Uses SDL3 instead of bespoke platform-dependent code

It is temporarily named VRSFML (https://github.com/vittorioromeo/VRSFML) until I officially release it.

You can read about the library and its design principles in this article: https://www.vittorioromeo.com/index/blog/vrsfml.html

You can read about the batching system in this article: https://www.vittorioromeo.com/index/blog/vrsfml2.html

You can find the source code here: https://github.com/vittorioromeo/VRSFML

You can try out the interactive demos online in your browser here: https://vittorioromeo.github.io/VRSFML_HTML5_Examples/

The target audience is mostly developers familiar with SFML who are looking for a library very similar in style but offering more power and flexibility. Upstream SFML remains more suitable for complete beginners.

I have used this fork to create and release my second commercial game, BubbleByte. It's open-source (https://github.com/vittorioromeo/VRSFML/tree/bubble_idle) and available now on Steam: https://store.steampowered.com/app/3499760/BubbleByte/

BubbleByte is a laid-back incremental game that mixes clicker, idle, automation, and a hint of tower defense, all inspired by my cat Byte’s fascination with soap bubbles.

A trailer is available here: https://www.youtube.com/watch?v=Db_zp66OHIU

streamlining the house to save money and sanity when we both start working and/or going to school

and starting to seriously start using a simple phone book

and mentally preparing for rent to go up or a car issue by causing controlled chaos and finding new ways to calm down as a family with as little money and energy as possible

by watching old movies from movie Madness, we're gaining insights into the origins of the items we use today. The futuristic visions of the sci-fi pioneers are serving as a Wikipedia of sorts, helping us break free from generational curses and regain a sense of control.

since it helps because, understandably, not being employed makes us feel ultra vulnerable, and that is not only normal but what the tech cults thrived on, but it is insane to take out our nerves on each other constantly and or/the animals. And to be on mass amounts of pharmaceuticals or heavy drinking is no walk in the park either in terms of ROI on keeping the embers of love and growing old, but Gandalf/Sith Lord grandaughter redemption President signed letter die at 102 years old happy clearly an attainable trajectory

As my upcoming birthday approaches, I can't help but feel that it might be the most special one yet. despite the tears, anger, and losses, I feel some reality based it is gonna be hakuna Matata SophiaG20

while zero jobs I see and know about are for me, I'm content knowing that my brain's imagination, creativity, and curiosity machine is still growing at 36. And feeling bad ass

read an article from Wired about Patricia Moore and honestly thinking about how Empathy and how the need for tech to let the ones like my mom freaking out and having plastic surgery and going overboard on Facebook and freaking out over menopause because she's 20 years older than when most of the women in our direct family died

I am inspired to find a real way to a home we actually own, a home we feel we have worked and earned. I am also motivated to soften the blows that life inevitably brings, such as the possibilities of allergies due to eventual menopause or the loss of a loved one. I see myself working for me and the current and women who are girls right now.

So tech will be more on their side not telling them to worry about the outside while the inside rots or worse something is off and no one cares or listens.

I am navigating these challenges on newly Medicare (newly disabled) and still finding ways to go back to the default feeling of being the fierce queen that I had when I was 5 years old with my grandpa.

but also letting the mind wonder so that others will be the fierce queens that they are because that is how my grandfather and his team made things after being POW in the holocaust, and he would want it for me and my badass mothers. Not to follow in what he did but find my own path for my own tribes with our own ways.

It feels like a rebirth of some kind for the trillionth time, but this time sober with a family (who loves me and I chose) and less toxic companies in my subscriptions or emails (because I nuked entirely the old Ecosystems which is making taxes pretty astonishing) like the intro to Hackers. Still, I killed myself online on purpose, crying and laughing, saying: don't threaten me with a good time On a Pixel and Samsung phone and Apple phone while Microsoft and all of them were like, NOOOOOOOOOOO!! ~ 20th Nov 2024, and it feels like that was a sinister evil evil Cult, but damn, reality tastes crisp, and there is more to chop to make it to 102. With the vibes still fresh from the interesting dozens on dozens of 100+ year-olds I took care of when I was 14-22 years old in Alaska and coming to terms my grandpa who I was TWO peas in a pod was one of the architects of DARPA and architects of NASA, and that is fricken cool

but now it is time to start pulling in the resources for this growing family instead of being salty about wasted time in Cults moving forward, like my father and grandfather's visionaries. I am finding a way forward by choosing not and withholding this visionary raw energy from DARPA and NASA because, in the end, all the promises they gave my grandpa did not happen. at. all.

And being cool with the fact that I will learn how to live life without ADHD meds even though it has been an option since I was 5 years old, but like the olds who came off Prozac recently, I want to start life anew without that stuff. 15 years is enough to say that shit wont get me to 102 years old comfortably with the family and loved ones knowing I'll be fine if 5-20 terrible terrible things happen back to back again.

People hate AI generated content, but the quality is actually good and Google likes it.