freedmand

Gift link (no subscription needed): https://www.nytimes.com/2025/08/19/business/chatgpt-gpt-5-ba...

Here's a gift link: https://www.nytimes.com/interactive/2025/03/26/business/ai-s...

Do you think that there are security or data exfiltration risks with their approach, e.g. putting classified documents/emails into private company's LLMs to summarize information or identify certain ideological motivations? I don't see how they could begin to understand the scope of what they're working with without A.I. assistance.

This will probably be my last run (2:49): https://youtu.be/zIyZJjyPy8U

Kudos on a great game! If you ever expand or open source this, let me know. The mechanics and design are great and could really blossom into something fun and expansive (especially if users could submit levels).

Oh wow, looks like someone uploaded a 2:55 yesterday: https://www.youtube.com/watch?v=G6yExxPR1vI

I'm by no means a speedrunner but decided to record my runs in case I got a sub-3. Just uploaded the 2:57: https://youtu.be/0THaZ61sCmg

I challenge someone to beat it!

I got 2:57 — required a near-perfect run but still room for improvement

I got 2:57 after discovering a few shortcuts

Can't say it'll solve all your problems, but try Florence-2. It's worked well on some handwritten documents for me when all the text is a relatively uniform size.

Model: https://huggingface.co/microsoft/Florence-2-large

Demo space: https://huggingface.co/spaces/gokaygokay/Florence-2

If you play ten note chords — one for each finger — in quick succession, that can rack up a lot of inserts in short time period (say, medium-worst case, 100Hz, for playing a chord like that five times per second, counting both “on” and “off” events).

It’s also worth taking into consideration damper pedal velocity changes. When you go from “off” (velocity 0) to fully “on” and depressed (velocity 127), a lot of intermediate values will get fired off at high frequency.

Ultimately though you are right; it’s not enough frequency of information to overload SQLite (or a file system), probably by several orders of magnitude.

Would you expect SQLite performance to degrade per insert once a table is very large (in a way that, say, an append-only log file wouldn’t)?

I recently had the idea to record every note coming out of my digital piano in real-time. That way if I come up with a good idea when noodling around I don’t have to hope I can remember it later.

I was debating what storage layer to use and decided to try SQLite because of its speed claims — essentially a single table where each row is a MIDI event from the piano (note on, note off, control pedal, velocity, timestamp). No transactions, just raw inserts on every possible event. It so far has worked beautifully: it’s performant AND I can do fun analysis later on, e.g. to see what keys I hit more than others or what my average note velocity is.

Agreed. Tesseract is not able to handle handwriting or text that is distorted well, e.g. colored text over an image background — to the point that it would hurt any downstream LLM trying to make sense of the contents. It won’t even pick out bounding boxes.

I doubt they are running an OCR model, but if they actually were it would likely be an in-house one trained with more modern techniques.

I just found this on HuggingFace: https://huggingface.co/mistralai/Mixtral-8x22B-Instruct-v0.1

The article from Bloomberg never said "racist" — it said tests revealed racial bias. The "racist" term is from the title refutation piece.

Each box is a torch module[1], which can technically encapsulate any amount of computation or contain sub-modules. The smallest boxes or leaf nodes are those that contain no sub-modules. They can still run an arbitrary number of functions depending on the node.

[1] https://pytorch.org/docs/stable/generated/torch.nn.Module.ht...

I wonder how people’s learning habits will change with AI tools like GitHub Copilot. I used it for several months but randomly got logged out and am now finding myself valuing the slight inconvenience of looking up official documentation (and surprised how much more sluggish I felt for the first week).

Going through extra steps to learn something through primary sources and valuing being uncomfortable at times are important for my evolution as a programmer.

Semantra! Shared it yesterday on HN https://github.com/freedmand/semantra

Hi HN, I’m excited to present Semantra, a tool and search UI where you can easily embed/query your own documents semantically (by meaning). Semantic embedding models are lightweight and can run on consumer grade CPUs. This project provides an embedding engine and human-in-the-loop web interface where you can run and iteratively refine queries. The project intentionally tries to make this interface as expressive and intuitive as possible without the use of any generative text models like ChatGPT. This makes the tool private, secure, and fast!

The tool is currently a Python CLI you pass files (text/PDF documents) into and it embeds them and launches a web UI. Embeddings are saved by file hash so files are only processed once and subsequent calls are instant. For a future direction, I am working on a native desktop app rewrite in Flutter and porting the project to use entirely C API-compatible libraries (which is a fun challenge when so many existing frameworks depend on Python). This will ideally make the tool easy for anyone to download and install and even opens up the possibility of mobile ports.

I’m excited to hear any comments or feedback! I’d love to know how it meets your needs and/or what features would make your lives easier.

I don’t fully understand the fascination with retrieval augmented generation. The retrieval part is already really good and computationally inexpensive — why not just pass the semantic search results to the user in a pleasant interface and allow them to synthesize their own response? Reading a generated paragraph that obscures the full sourcing seems like a practice that’s been popularized to justify using the shiny new tech, but is the generated part what users actually want? (Not to mention there is no bulletproof way to prevent hallucinations, lies, and prompt injection even with retrieval context.)

I don't disagree with anything you said.

I'm saying more that if the compression algorithm is benchmarking against "Alice in Wonderland" and has consumed the entirety of "Alice in Wonderland" in training the LLM (along with popular paragraphs and sentences quoted elsewhere), then it might do particularly well at reciting lines from that book and thus be able to compress it extremely well. I'd be more interested in seeing the compression algorithm's performance on new or unreleased works that would have no way of being training data.

As an extreme hypothetical, I could make a compression algorithm that is a table mapping an ID to an entire book and fill it with all the popular works. "Alice in Wonderland" would be replaced with a single short identifier string and achieve a ~0.001% compression ratio. An unseen work would be replaced with an <unknown> ID followed by the entire work and be slightly bigger. Then, I benchmark only the popular works and show insanely impressive results!

I have no doubt the LLM compressor would do really well on unseen works based on what you said above, but it's not a fair look at its performance to run it on works it may have been explicitly trained on.

Was it run on any text that was not feasibly training data for the LLMs? It wouldn't be a fair comparison otherwise

I have proof-of-concepted[1] building an entirely static website offering client-side semantic search using transformers.js[2] and Semantra*[3] with MiniLM-L12[4]. It's usable on fast connections and decent CPUs but is not delightfully fast and can't handle huge document loads. Still could be useful for some embedded documents! I hope to incorporate an auto-builder for these experiences in the next big release of Semantra.

[1] https://twitter.com/dylfreed/status/1651572024488218627

[2] https://xenova.github.io/transformers.js

[3] https://github.com/freedmand/semantra *(author of this tool)

[4] https://huggingface.co/sentence-transformers/all-MiniLM-L12-...

Never shared this before, but I had a phase where I built satirical landing pages and of them was “Words: The programming language for ideas”

https://readymag.com/dylan/words/

Wait til you see all the copyrighted and pirated data most large language models are trained on:

- https://www.washingtonpost.com/technology/interactive/2023/a...

- https://pile.eleuther.ai/ (data hosted by https://the-eye.eu/, where it's not too hard to find pirated, copyrighted books, e.g. https://the-eye.eu/public/Books/cdn.preterhuman.net/texts/li...)

I’ve been doing something similar to control racing video games while biking on an indoor exercise bike. I convert pedal speed into brake and acceleration keys (there’s some middle amount of pedaling that’s neutral) with pynput. I used OpenCV for webcam input and MediaPipe’s models to convert lean angle into left and right keyboard presses, and head tilt into up and down. It’s really fun but the slight latency in recognizing my pose is tough for fast courses. Now I’m thinking about some Arduino with a sensor or low res IR camera or something else that could detect changes a lot quicker.

Ooh TIL about plug-ins like Scaler 2. I need to get more immersed in the DAW world.

It'd be cool to train text embeddings and musical chord embeddings (by analyzing song lyrics perhaps) and then build something to type in moods like "happy jaunty progression" and get a matching chord progression with a similar embedding (assuming you give it a large library of progressions). No generative AI would be needed :)

Yep. Using AI at all here feels like overkill. You could get interesting results just choosing random chords* in the key signature.

*speaking from experience. I built a web app at tapcompose.com (desktop only for now) that uses pure randomness for both chords and melody. Initially I used randomness for testing only and planned to substitute an AI model later — but I was delightfully satisfied with the results and kept it in

That's a big part of the reason I built the open source tool Semantra[1]. I only really trust the semantic search part of this problem as it is constrained by context, so I tried to make the user experience good on top of simpler semantic search without any chatbot capabilities.

[1] https://github.com/freedmand/semantra

Hi everyone, I built Semantra over the past four weeks to showcase the power of semantic search and share the experience. I strived to make a general purpose tool so that others could easily spin up their own semantic search engines over their own content.

Semantra is a Python CLI that analyzes specified documents (text/pdf files), embeds them in chunks of text, and launches a local web server to interactively query them by semantic meaning. It is highly configurable and offers different embedding models, from Hugging Face transformers model (e.g. ones from SentenceTransformers) to OpenAI's embedding model (text-ada-embeddings-002).

The web app allows iteratively refining queries via tagging and adding/subtracting additional queries, allowing for very expressive and refined search experiences. It also presents "explanations" for search results by highlighting sub-regions within the results that most closely match the query.

Take it for a spin! `pipx install semantra`

---

Detailed instructions, tutorial, guide, and concept documentation at the repo: https://github.com/freedmand/semantra

Twitter thread with demo videos/content: https://twitter.com/dylfreed/status/1650268405881085952