- #zig
    - Hitting Peak File IO Performance with Zig
        - axboe/fio: Flexible I/O Tester
        - steelcake/csio: Cooperative scheduling and IO library
        - DataDog/glommio: Glommio is a thread-per-core crate that makes writing highly parallel asynchronous applications in a thread-per-core architecture easier for rustaceans.
        - steelcake
- #jj
    - Let `jj absorb` help you keep a clean commit history
    - Merge Conflicts: Avoiding Them, Making Them Less Painful | Games by Mason
    - Quuxplusone/difdef: Utility to do an N-way diff and N-way merge, for N2. Uses the patience diff algorithm.
- #disect
    - Video compression basics – RasterGrid | Software Consultancy #cut
    - A Secret Web
    - In-memory Filesystems in Rust #rust #os

- Making a font of my handwriting · Chameth.com #design
    - On HN
        - https://ownfonts.cielo.ovh/
        - https://www.amygoodchild.com/blog/cursive-handwriting-in-javascript

    > Calligraphr works by having you print templates, write out the letters, then scan them in.

    > I added the “minimal English”, “basic punctuation” and “Ligatures” sets.

- #ph
    - basketballguy999/Quantum-Mechanics-Concise-Book: A concise text on quantum mechanics, intended for a general audience including CS, engineering, math, and physics undergrads, as well as anyone interested in a concise intro/overview of QM. Prerequisites: linear algebra, calculus, high school physics
    - This idea must die
- #formal
    - Formality on demand

- #rust
    - Stackerror
    - the core of rust
        - https://without.boats/blog/revisiting-a-smaller-rust/
    - There is no memory safety without thread safety (on HN) (on lobste.rs)
    - Default musl allocator considered harmful (to performance)
- #agent
    - Agentic ProbLLMs - The Month of AI Bugs 2025 #sec
        - On lobste.rs
    - AGENTS.md
    - A Guide to Gen AI / LLM Vibecoding for Expert Programmers - Stochastic Lifestyle
        - On HN
    - Language Models as Thespians
        - On lobste.rs
- #agent/idea
    - DeepSeek v3.1 Is Not Having a Moment
    - Vibe Debugging: Enterprises' Up and Coming Nightmare
    - Bank forced to rehire workers after lying about chatbot productivity, union says
    - The Unbearable Slowness of AI Coding
    - Why language models hallucinate
    - Simon Willison | A quote from u/AssafMalkiIL

        > what’s the point of vibe coding if at the end of the day i still gotta pay a dev to look at the code anyway.

        > i cant vibe my way through debugging, i cant ship anything that actually matters, and then i’m back to square one pulling out my wallet for someone who actually knows what they’re doing.

- #openweb
    - No, Google Did Not Unilaterally Decide to Kill XSLT
    - Should the web platform adopt XSLT 3.0? · Issue #11578 · whatwg/html
    - Croissant is Coming for You
    - XSLT: A Precision Tool for the Future of Structured Transformation (on HN)
- #disect
    - Bash Strict Mode
        - I should review my scripts based on what's learned from this
        - Getting decent error reports in Bash when you're using 'set -e' (on HN) (on lobste.rs)
        - Heredocs Can Make Your Bash Scripts Self-Documenting
    - Introduction to AT Protocol #fediverse
            - On HN
    - #gpu
        - Learning About GPUs Through Measuring Memory Bandwidth | Evolve
        - How to Think About GPUs | How To Scale Your Model
                - On HN

- #selfhost
    - Static Sites with Python, uv, Caddy, and Docker | Blog | Nik Kantar
        - Coolify Docs
    - GDPR-compliant European static site hosting - statichost.eu
            - https://www.statichost.eu/blog/statichost-hosting/
- #tui
    - jocalsend - Terminal Trove #selfhost/data
    - hapless - Terminal Trove
- #openweb
    - Google is killing the open web #openweb
            - On HN
            - On lobste.rs
    - Simon Willison | XSLT on congress.gov
    - Remove mentions of XSLT from the html spec by mfreed7 · Pull Request #11563 · whatwg/html
        - On HN
- D2 (text to diagram tool) now supports ASCII renders #diagram
- #browser
    - How to firefox (on HN)
    - Why I'm all-in on Zen Browser
            - On HN
            - https://addons.mozilla.org/en-US/firefox/addon/sidebery/
            - https://github.com/mbnuqw/sidebery/wiki/Firefox-Styles-Snippets-(via-userChrome.css)
            - https://github.com/greeeen-dev/natsumi-browser
            - https://github.com/akkva/gwfox
    - How I Use Kagi
        - on HN
    - Microsoft Introduces 'Copilot Mode' in Edge (on HN)
    - Show HN: Monchromate – the best greyscale browser extension (on HN)
        - f.lux: software to make your life better
- #sec
    - A Brief, Incomplete, and Mostly Subjective History of Internet censorship and its countermeasures
    - Simon Willison | PyPI: Preventing Domain Resurrection Attacks #py
        - Preventing Domain Resurrection Attacks (on the Python Package Index) #py
            - On HN
    - Vet is a safety net for the curl | bash pattern (on HN)
        - Don’t distribute packages via curl | sh (but not for the reasons you think) - HedgeDoc

- PixiEditor #cg
- #idea
    - Left to Right Programming
        - On HN
        - On lobste.rs
    - Why developers question everything - Tim Hårek
        - On lobste.rs

- #zig
    - zg: Unicode text processing for Zig projects
    - Zig; what I think after months of using it

        > Focus on debugging your application rather than debugging your programming language knowledge.

        > A structure has two sizes: its bit-size, and its byte-size.

        > A regular value T coerces to E!T, and an error type E coerces to E!T

        > You can iterate on the contents of c with an inline for at comptime to transform functions the way you want.

    - Packaging Zig as Python packages #py #pkg
    - The Python Package Index Should Get Rid Of Its Training Wheels #py
    - Zig Parser #disect
    - Retro Rogue-Like: Modular Programming in C
    - Looking for examples of clean zig APIs
        - vrischmann/zig-sqlite: zig-sqlite is a small wrapper around sqlite's C API, making it easier to use with Zig.
        - Mario-SO/ohlcv: OHLCV library in zig
        - (266) Code Guild
- #lean
    - Lean Game Server
    - Doing Lean Dirty: Lean as a Jupyter Notebook Replacement
        - https://types.pl/@sandmouth/114813276765190938
- tooling
    - Enforce Proper direnv Setup #mise
    - #helix
        - Helix Plugins
        - Are any of these features available in Helix? · helix-editor helix · Discussion #3156
        - feat: support using Yazi in Helix directly without Zellij or tmux by sxyazi · Pull Request #2461 · sxyazi/yazi
        - try to use yazi inside of helix

        - helix-editor/helix#1125: automatic reload when file changes externally
    - #mac/wm
        - nikitabobko/AeroSpace: AeroSpace is an i3-like tiling window manager for macOS
        - AeroSpace
- #tui
    - habedi/chilli: A microframework for creating command-line applications in Zig
    - Todomvc tui
    - helix/helix-tui at master · helix-editor/helix
- #typst
    - The Math Mode Problem | Laurenz's Blog
    - The (Typst) Math Mode Problem | Laurenz's Blog : r/typst
- #cpp/interop
    - robertoraggi/cplusplus: A compiler front end for the C++ language
    - shedskin/shedskin: Shed Skin is a restricted-Python-to-C++ compiler. Read the introduction below to learn about the restrictions.
- Are "w/o", "w/", "b/c" common abbreviations in the US? #natlang
- Tommaso Gagliardoni's Homepage #qc
    - a reply to *Replication of Quantum Factorisation Records with an 8-bit Home Computer, an Abacus, and a Dog*
- A Diagrammatic Calculus for a Functional Model of Natural Language... #diagram #paper

- #sovereign
    - #kb
        - Writing Documentation and Prose in Markdown Using Helix

            > :reflow is Helix’s version of hard wrap and makes permanent changes to your formatting. The line length can be set with text-width in your config.

            > Type [ to automatically create a pair using automatic pair completion, then type the image link text inside it.

            > Press Tab to skip over the closing ] using the smart tab feature.

            > Marksman helps you quickly find and jump to specific headings or anchor tags in a document.

            > Open the Symbol Picker: Press Space s.

            > Vale stands out by enforcing custom style guides for technical writing alongside spell checking, though its grammar checking is less advanced. Its newly introduced language server is still basic.

        - Reading and writing notes with yazi and helix #helix
        - xwmx/nb: CLI and local web plain text note‑taking, bookmarking, and archiving with linking, tagging, filtering, search, Git versioning & syncing, Pandoc conversion, + more, in a single portable script. #tui
        - Building Bluesky Comments for My Blog
        - Raindrops | API Documentation
        - Switching to Obsidian
            - from Notion
        - Allow me to introduce the two-sentence journal #design

            > A daily journal entry could be as simple as "[description of occurrence] + [its upshot]," adapted as necessary.

            > an interesting thing happens when you present a reader with only two sentences: Somehow, a narrative logic appears.

        - The append-and-review note (on HN)
            - Heynote
        - Observable Notebooks 2.0 Technology Preview | Observable #nb
        - Apache ECharts 6
            - ECharts is my go-to libary for visualization of data for better interpretability
        - Ask HN: What Pocket alternatives did you move to?
            - Obsidian Web Clipper
            - Home - Readeck
    - #kb/dataview
        - Codeblock Reference - Dataview
        - blacksmithgu/datacore: Work-in-progress successor to Dataview with a focus on UX and speed.
        - dsebastien/obsidian-dataview-serializer: Obsidian plugin that gives you the power of Dataview, but generates Markdown, making it compatible with Obsidian Publish, and making the links appear on the Graph.
        - Enveloppe
        - "Burning out" dataviews · Issue #42 · blacksmithgu/obsidian-dataview
        - Support for Dataview JS Snippets · Issue #102 · jackyzha0/quartz
        - 7sedam7/krafna: Obsidion dataview plugin-like tool for command line.
    - #selfhost/data
        - embedpdf/embed-pdf-viewer: A PDF viewer that seamlessly integrates with any JavaScript project
        - What Exif Data Reveals About Your Site #privacy
        - houqp/kiorg: A hacker's file manager with VIM inspired keybind
        - Watchman - A file watching service | Watchman
        - pascalkuthe/filesentry: A reliable and performant cached directory tree in rust that can notify changes without dropping events
    - #selfhost/data #sec
        - hashcat - advanced password recovery
        - Brute-Force VeraCrypt Encryption – CodeOnBy
        - trufflesecurity/trufflehog: Find, verify, and analyze leaked credentials
    - #forge
        - GitHero
        - GitHub is no longer independent at Microsoft after CEO resignation | Hacker News
            - On HN
            - Give Up GitHub - Software Freedom Conservancy
    - #ci
        - bahdotsh/wrkflw
            - On lobste.rs
            - from https://this-week-in-rust.org/blog/2025/08/13/this-week-in-rust-612/
        - The best developer experience in CI/CD - RWX
        - Reverse Engineering the GHA Cache to Improve Performance (on HN)
            - Reverse engineering GitHub Actions cache to make it fast | Blacksmith
        - Using Radicle CI for Development (on HN) (on lobste.rs)
    - #openweb
        - Mac Open Web, by Brian Warren
        - Reeder
        - Kill the Newsletter!
    - pocketbase/pocketbase: Open Source realtime backend in 1 file #stack
    - #browser
        - Ok... even I think that's a bit of a stretch... : r/diabrowser
        - Text browsers · TecharoHQ anubis · Discussion #418
        - Arc still going good, btw windows! : r/ArcBrowser
        - Deta Surf
        - Orion is the first WebKit browser to feature an Arc-like navigation logic for vertical tabs : r/ArcBrowser
        - How are Dia and Arc team the same ? : r/diabrowser
- #oss
    - "This is a Low Maintenance Project"
    - Open Source is Not About You
    - My FOSS Story - Andrew Gallant's Blog
    - Geomys, a blueprint for a sustainable open source maintenance firm (2024)
    - In the long run, GPL code becomes irrelevant (2015) (on HN)
    - NIH is cheaper than the wrong dependency (on HN) (on lobste.rs)
    - NPM 'accidentally' removes Stylus package, breaks builds and pipelines
    - Simon Willison | Introducing OSS Rebuild: Open Source, Rebuilt to Last #sec

        > the Google Security team have announced OSS Rebuild, their project to provide build attestations for open source packages released through the NPM, PyPI and Crates ecosystom

- #agent/idea
    - LLM Daydreaming
    - LLMs aren’t world models
    - openai burns the boats #biz
    - Why Does AI Feel So Different? - nilenso blog

        > - Thinking by questioning (Socrates)
        > - Thinking by logic (Aristotle)
        > - Thinking by observing: Empiricism / Scientific Method (Bacon)
        > - Thinking by heuristics and biases: System 1 and 2 (Kahneman)
        > - Thinking by… augmentation? (AI)

- #rust
    - rosefromthedead/effing-mad: Algebraic effects for Rust #pl
    - Memory Safety is a Red Herring #go #cpp
    - Lessons learned from implementing SIMD-accelerated algorithms (ChaCha20 / ChaCha12) in pure Rust #asm
    - async-recursion #async
    - rust-lang/rust-bindgen #cpp/interop
    - krabby: a highly optimized Rust compiler
        - https://sr.ht/~bal-e/krabby/
    - Krabby: a WIP high-performance Rust compiler
    - from https://this-week-in-rust.org/blog/2025/08/13/this-week-in-rust-612/
        - Building an Asynchronous FUSE Filesystem in Rust
        - Lessons learned from implementing SIMD-accelerated algorithms (ChaCha20 / ChaCha12) in pure Rust #asm
    - bliki: Yagni #idea
    - from parasyte/task-webapp: Stop Web App Bloat! #web
- #gleam
    - Gleam, coming from Erlang
    - Using use in Gleam
    - Why Elixir? Common misconceptions (on HN) #elixir
- Who Will Maintain Vim? A Demo of Git Who #tui
- #py #pkg #biz
    - pyx: a Python-native package registry, now in Beta
        - Simon Willison | pyx: a Python-native package registry, now in Beta

            > What I want to do is build software that vertically integrates with our open source tools, and sell that software to companies that are already using Ruff, uv, etc. Alternatives to things that companies already pay for today.

            > stays true to Charlie's promises to carefully design the incentive structure to avoid corrupting the core open source project that the Python community is coming to depend on

- #design
    - How to make absolutely any app look like a macOS app—Martian Chronicles, Evil Martians’ team blog
    - font-size-adjust Is Useful
    - Why Racket? Why Lisp? | Butterick’s Practical Typography
    - Choosing typeface
    - I'm Worried It Might Get Bad #idea
    - Blog | Fabián's Journal
- #struct #crdt
    - Welcome to Automerge | Automerge CRDT
        - CRDT: Text Buffer - Made by Evan #struct
        - Automerge 3.0
    - Ethersync: Peer-to-peer collaborative editing of local text files
    - A CRDT-based Messenger in 12 Lines of Bash Using a Synced Folder
        - how about an editor? edits can't be dealt with in the same manner

- Simon Willison | Cloudflare Crawler Hints triggers crawls from Yandex and Bingbot - nothing to do with ChatGPT Agent
    - it's actually Crawler Hints by Cloudflare
- Content-Aware Spaced Repetition
    - FSRS is both Content-agnostic as well as Deck-agnostic, it might underfit a lot  (from HN)
- Diagrams For Yourself
    - the author doesn't want to use something off-the-shelf like Mermaid or TikZ, and want it to look bespoke, something homemade with a slightly distinctive style
- #qa
    - Getting Started with Randomised Testing
        - Property-Based Testing
            - describe a range of values
            - sample from the range
            - checks if any trigger your assertions
    - Code Factor
        - e.g. Code Factor | habedi/chilli - Overview
            - from habedi/chilli: A microframework for creating command-line applications in Zig
    - Expressive test assertions without testify/assert #go
- New comment by backprop1989 in "Tell HN: Anthropic expires paid credits after a year"
    - Accounting rules: If the credits last indefinitely, any unused credits cannot be counted as revenue.
- Open Sourcing Shaper: Minimal Data Platform for Embedded Analytics
    - built on top of DuckDB and NATS.io – Cloud Native, Open Source, High-performance Messaging
- Qwen-Image: Crafting with Native Text Rendering
    - 5 percent of the training data was data "synthesized through controlled text rendering techniques", ranging from simple text through text on an image background up to much more complex layout examples
- #formal
    - What I Wish I Knew When Learning Picat
        - My Picat page
    - Practical Static Analysis for Privacy Bugs
    - Binding Application in Idris

- #rust
    - Perhaps Rust needs "defer"
        - an example that using defer idiom rarely gets past the borrow checker
        - showcases well how working in Rust with lots of FFI interop feels like
        - `miri` used in iterations
        - from comments of A deep dive into Rust and C memory interoperability
    - The Generativity Pattern in Rust
- DrawAFish.com Postmortem
    - used childhood 6-digit password when creating the website
    - set up Google Auth, then used it ever after
    - forgot that the password remained
    - which was previously leaked
- God created men; Sam Altman made them equal
    - hyperstition: a cultural self-fulfilling prophecy
        - pessimism is an anti-myth that makes Mutual Destruction inevitable. Pessimism is a luxury we can no longer afford.
        - the future is unavoidable, but we are always writing its prologue.
        - techno-optimistism is now a necessity
    - Malcolm Gladwell's cardinal categories of Law & Order provide a compass for tech-induced power redistribution:
        - Western
            - there’s no system
                - AI evades law
            - movies
                - Ex Machina
                - 2001: A Space Odyssey
                - Transcendence
                - Her
                - Blade Runner
                - Neuromancer
                - Ghost in the Shell
        - Northern
            - there’s a system and it’s fantastic
                - AI enforces law
            - movies
                - Person of Interest
                - RoboCop
                - Iron Man
                - Knight Rider
                - The Machine
        - Southern
            - the system has to be reformed from the outside
                - outsiders against AI
            - movies
                - The Matrix trilogy
                - Eagle Eye
                - Alita: Battle Angel
                - Free Guy
                - The Terminator
                - Hackers
                - Johnny Mnemonic
                - eXistenZ
        - Eastern
            - the system is reformed from within
                - insiders against AI
            - movies
                - Short Circuit
                - Minority Report
                - Sneakers
                - I, Robot
                - Westworld
                - War Games
                - A.I. Artificial Intelligence
                - Wall-E
- Governance in GNOME
    - A “bottom up” approach, over-reliance on personal projects and taste, to be sublimated into a shared vision
    - options for maintainers
        - make yourself indispensable, so that everything ends up passing through you, and everyone has to defer to your taste, opinion, or edict
        - replicate your toughts, taste, and opinions into the minds of the people using the API you design
        - reimplement the entirety, a reflection of your taste, commitment, and ethos
    - governance
        - a structure for people to know what to expect and how to navigate the decision making process inside the project
            - responsibility is not something to hoard: it’s something to distribute
            - random GitLab issues should not be the only place where people can be informed that some decision was taken
            - individuals should be able to contribute to a decision without necessarily becoming responsible for a whole project
            - a single person responsible for multiple modules should not be able to design and commit on their own
        - a lightweight but well-defined process
            - discussion: present to the stakeholders, for iteration and consensus
            - documentation: for reference to the decision-making process and resolution during implementation and on-going developments
    - reminds me of ADR
- HTMX is hard so let's get it right
    - many alternatives are suggested on HN
- Maybe the Fastest Disk Usage Program on macOS
    - healeycodes/dumac: 🗃️ Very fast alternative to 'du -sh' for macOS that uses getattrlistbulk.
    - in #rust, with tokio::task
    - macOS has a syscall called getattrlistbulk(2) which allows you to read multiple directory entries and their metadata in one go. It's like a combined "readdir + stat" that returns a batch of file names along with requested attributes like file type, size, etc.
    - inspired by the Linux equivalent 201984/dut: A disk usage calculator for Linux - Codeberg.org
- Modern Node.js Patterns
    - most of them are news to me, it's glad to learn that nodejs has aquired so many desirable features
    - wonder if they apply to Bun as well
- #agent/idea
    - Does the Bitter Lesson Have Limits? (on HN)
        - The Bitter Lesson
            - trying to build knowledge into agents plateaus and even inhibits further progress in the long run
            - breakthrough progress eventually arrives by an opposing approach based on scaling computation by search and learning
        - four major blows to the human ego
            - The Copernican Revolution: we weren’t the center of the universe.
            - Darwinian thought: we weren’t separate from animals.
            - Freud’s ideas of the unconscious: we weren’t in full control of our selves.
            - Cyborgs, robots, and automatons: non-humans could do the work of humans.
        - Garbage Can Model
            - organizations as chaotic “garbage cans” where problems, solutions, and decision-makers are dumped in together
            - decisions often happen when these elements collide randomly, rather than through a fully rational process
            - represents a world where unwritten rules, bespoke knowledge, and complex and undocumented processes are critical
        - issues of the bitter lesson
            - dependent on high-quality data
            - adding compute is often not practical nor optimal
    - Read your code (on HN)
    - The Future Of Software Is Small
    - Typed languages are better suited for vibecoding (on HN)
    - Rust, Python, and TypeScript: the new trifecta

- How do you backup your non-work-related data?
    - most suggests `restic`
    - Cloud Backup: Easy, Secure, Unlimited Online Backup
        - Backblaze B2, good affordability/pricing, ~$5/mo
    - `borg` has security footgun
    - use https://healthchecks.io/ to monitor backup jobs
    - Append-only Restic backups on a Hetzner Storage Box
        - good #design, [source]
        - Append-only backups with restic and rclone
    - jmtd → computing → Network Attached Storage (NAS)
    - Personal backups and file archival // Josh Mock
- If you're remote, ramble
    - Ramblings channels let everyone share what’s on their mind without cluttering group channels
        - short updates 1-3 times per week
        - common topics
            - ideas related to current projects
            - musings about blog posts, articles, user feedback
            - “what if” suggestions
            - photos from recent trips or hobbies
            - rubber ducking a problem
    - each ramblings channel
        - named after the team member
        - only that person can post top-level messages. Others can reply in threads, but not start new ones
        - muted by default, with no expectation that anyone else will read them
    - ramblings are our equivalent of water cooler talk
- Linear Types for Programmers (2023) #lang
    - The Austral Programming Language
    - faiface/par-lang: Par (⅋) is an experimental concurrent programming language. It's an attempt to bring the expressive power of linear logic into practice.
- Twenty Eighth International Obfuscated C Code Contest
    - the redesign broke all links to the old entries without redirects
    - now requires using a javascript capable browser to view the entries on github (github having removed non-JS access last year)

- #agent
    - Cerebras Code
        - Cerebras Code Pro ($50/month)
        - Code Max ($200/month)
        - Qwen3-Coder, but at 2,000 tokens per second, with a 131k-token context window
    - cchistory: Tracking Claude Code System Prompt and Tool Changes
    - Reconstructing a timeline for Amazon Q prompt infection #sec
        - Amazon's AI Coding Revealed a Dirty Little Secret (on HN)
    - NativeMind
- Unit Testing Principles
    - overcomplicated code should be split into
        - deep domain classes, to be thoroughly unit tested
        - wide controllers, exercised by strategic integration tests
    - unit tests should verify units of behavior
    - four pillars of a good unit test
        - protection against regressions
        - resistance to refactoring
        - fast feedback
        - maintainability
    - I think I have got them all wrong when setting up tests for GAlgebra
- #lib
    - candyfloss: an ergonomic python library for running video pipelines

- #agent
    - 6 Weeks of Claude Code (on HN) (on lobste.rs)
        - "a list of things which I have completed, solo, ..., they are years of “tech debt” / “tech innovation” backlog for me"
        - Individual Contributor Ladder
    - AI is a floor raiser, not a ceiling raiser
        - on HN
            - AI is "automated ladder pulling technology"
            - "AI does all those lower level jobs, puts the people who need those jobs for experience on the street, and robs us of future experts."
            - 'A black hole': New graduates discover a dismal job market
    - Vibe code is legacy code
        - "We already have a phrase for code that nobody understands: legacy code"
    - A Hitchhiker's Guide to the AI Bubble
        - "The fact there is real value in the technology does not contradict in any way that we are in a bubble."
    - Trying out Qwen3 Coder Flash using LM Studio and Open WebUI and LLM
        - "A neat feature of Open WebUI is that it includes an automatic preview panel, which kicks in for fenced code blocks that include SVG or HTML"
- #sec
    - How to Secure a Linux Server (on HN)
        - however, it's pointed out on HN that one should not follow this
            - "This guide ignores many sane defaults in favor of a patchwork..., added over time by random people with no thought for threat modeling, that may even result in an increased attack surface."
            - "This guide contains (at least) inaccurate statements. It's oversimplifying and omitting important things while putting emphasis on some exotic details where defaults would be sane enough."
        - better alternatives suggested, both authored by `a13xp0p0v`
            - Linux Kernel Defence Map - Security Hardening Concepts (on HN)
            - Linux Kernel Hardening Checker (on HN)
        - ComplianceAsCode/content: Security automation content in SCAP, Bash, Ansible, and other formats is also suggested
            - it facilitates security policy content authoring
            - along with ansible playbook/bash scripts to check or fix compliance
    - When Flatpak’s Sandbox Cracks: Real‑Life Security Issues Beyond the Ideal | Linux Journal
- Hyrum's Law
    - "With a sufficient number of users of an API, it does not matter what you promise in the contract: all observable behaviors of your system will be depended on by somebody"
    - "corollary: even if you explicitly deny a guarantee of a certain behavior in your contract, if you usually deliver that behavior, most of your customers will depend on it."
- Long Term Support for SQLite
    - admirable efforts to support SQLite through the year 2050
- Live coding sucks | Mustapha Hadid
    - "Live coding interviews measure stress, not coding skills"
    - Comment by lapcat
        - "something about strangers standing over my shoulder judging me, determining my financial future by providing or withholding a job, like the sword of Damocles, turns my stomach inside out"
        - "A lot of commenters causally speak of "false negatives" as if they were random, but some people, myself included, are always the false negative."
- #tmux
    - Replacing tmux in my dev workflow (on HN) (on lobste.rs)
        - shpool + autossh(1)
    - Customizing tmux
        - lots of potentially useful comments on on HN

- #perf
    - Benchmarks in CI: Escaping the Cloud Chaos
    - Big O vs Hardware: Better Complexity ≠ Better Performance
    - bu/doc/tim.md at main · c-blake/bu
    - Snooping On Slow Builds (Using Syscalls)
- #browser
    - I tried Servo, the undercover web browser engine made with Rust #rust
        - "this approach of breaking down a web engine into independently usable modules with public APIs will make it easier for people to get involved in web engine development, and make it easier for people to create new web engines in future" (on HN)
            - servo/stylo: CSS engine that powers Servo and Firefox
            - servo/html5ever: High-performance browser-grade HTML5 parser
            - DioxusLabs/taffy: A high performance rust-powered UI layout library
            - DioxusLabs/blitz: A radically modular HTML/CSS rendering engine
    - Orion Browser by Kagi
        - Kagi believes that they need to offer a hollistic replacement for big tech for consuming the web, that includes search, browser and email  (on HN)
    - How we made JSON.stringify more than twice as fast
- #cg
    - PixiEditor 2.0 – A FOSS universal 2D graphics editor (on HN)
        - Raster, Vector, Animations, Procedural (VFX, effects, non-desctuctive editing)
        - written in C#, copyleft
        - alternatives
            - G'MIC - GREYC's Magic for Image Computing: A Full-Featured Open-Source Framework for Image Processing - Main
    - Kdenlive - Free and Open Source Video Editor
    - Physically Based Shading in Theory and Practice
    - 3D Line Drawings
        - a 3d scene that can be posed and shows as a 2d line illustration
        - based on Gaussian Splats

- #zig #perf
    - Zig profiling on Apple Silicon | Bugsik
        - mstange/samply
            - a command line sampling CPU profiler which uses the Firefox profiler as its UI
            - for macOS, Linux, and Windows
        - verte-zerg/poop at kperf-macos
            - a fork of poop to use kperf under Mac
        - wolfpld/tracy: Frame profiler
            - A real time, nanosecond resolution, remote telemetry, hybrid frame and sampling profiler for games and other applications
            - C, C++, Lua, Python, Fortran, Rust, Zig, C#, OCaml, Odin, GPU
            - Windows, Linux, Android, FreeBSD, WSL, OSX, iOS, QNX
    - Generic Programming and anytype - Docs - Ziggit
    - Using Zig allocator for C libraries (Alignment question)
        - `Allocator.rawAlloc`/`.rawFree`
        - `@alignOf(std.c.max_align_t)`
    - ANDRVV/zprof: 🧮 Cross-allocator profiler for Zig
        - battle-tested in raptodb/rapto: transposition-heuristic storage, low memory footprint and high-performance querying
    - Writing memory efficient C structs (on HN)
    - 10^19712 years to exhaust u65535
        - u65535 is the integer type with the highest max value supported in Zig (from Zig doc)
- #physics
    - Background independence
- #crypto
    - Fintech dystopia (on HN)
- #perf
    - Giving Benchmarks a Boat
        - TPC-C is a benchmark for transactional databases that models an order system with goods spanning many warehouses
        - Each warehouse comes with some set amount of data to be managed and some amount of query traffic that adheres to some specific distribution laid out in the spec
            - they can account for
                - what's the proportion of hot vs. cold data
                - what's the ratio of transactions-per-minute to bytes stored
                - what's the proportion of read-only queries, vs. simple, point writes, vs. complex read-write transactions
                - what proportion of transactions go cross-shard
        - The metric: "we sustained the workload at X warehouses with Y hardware at Z cost."
- #movie
    - Nothing to watch – Experimental gallery visualizing 50k film posters
- #agent
    - Show HN: A GitHub Action that quizzes you on a pull request (on HN) #aicr

        > PR Quiz uses AI to generate a quiz from a pull request and blocks you from merging until the quiz is passed.

    - Principles for production AI agents (on HN)
        - context
            - modern LLMs just need direct detailed context, no tricks, but clarity and lack of contradictions
            - structuring context so that the system part is large and static and user one is small and dynamic works great
            - provide the bare minimum of knowledge in the first place, and the option to fetch more context if needed via tools
            - context compaction tools can help avoiding logs and other artifacts from the feedback loop to bloat the context
        - tools
            - good tools typically operate on a similar level of granularity, and have a limited number of strictly typed parameters
            - idempotency is highly recommended to avoid state management issues
            - LLMs are very likely to misuse your loopholes, and that’s why you don’t want to have any loopholes
                - v.s. human API users are more capable of reading between the lines, can navigate complex docs and find workarounds
            - designing an agent to write some DSL (domain-specific language) code with actions rather than calling tools one by one is a great idea
        - feedback loop
            - actor-critic approach: where an actor decides on actions and a critic evaluates them
                - allow actors to be creative, and critics to be strict
            - error recovery
                - a chain of bad fixes is not fixable anymore - just discard and try again
            - agents try alternatives because the explicitly requested tool call failed with crucial ingredients
                - tell them to ask for these ingredients before trying alternatives
            - baseline agent + logs + LLM analysis = insights for improvments
    - Q&A: Combining Math and LLMs
        - Raw math/algos and LLM are both powerful tools in your modeling toolkit
        - If you’re missing either tool from your toolkit, then that will severely hamstring your modeling abilities and many problems will remain inaccessible to you.
    - Show HN: Companies use AI to take your calls. I built AI to make them for you
        - top comment on HN introduced a great use case for LLM-back reception
            - local plumbing business
                - understand and repeated back the client's request in a slightly different, more professional way for confirmation
                - asked a few more smart follow-ups
                - the plumber called back and jumped straight into solutions, pricing, and his availability
            - prefer to talk to LLM, if the issue can be quickly triaged to the right human who actually understand the situation
            - synchronous interaction by bot
                - can perform first level troubleshooting, ask for clarification, begin to form a plan and get your buy-in
                - v.s. fire-and-forget email form
                    - incomplete reports, missing information, people who have no idea what they're talking about
    - Show HN: Terminal-Bench-RL: Training Long-Horizon Terminal Agents with RL (on HN)
        - Custom scaffolding (system prompt and tools) using Qwen3-32B achieved 13.75- The author has built an RL system, but it has not been used for anything due to cost limitations.
    - Stop selling “unlimited”, when you mean “until we change our minds”
        - the playbook
            - launch with generous/unlimited limits
            - build user dependency
            - add caps targeting "less than 5- frame as "sustainability" or "fairness"
        - that "5- power users with deep workflow integration
            - early adopters who took platform risks
            - team influencers who drive organizational adoption
            - $200/month Claude Max subscribers doing serious work
        - Tokens are getting more expensive
        - Claude Code weekly rate limits
    - The Rise of Vibeinsecurity
        - a story about how devs lost their jobs over vibe apps, and vibe apps are hacked by vibe hackers immediately after deployment
        - this is also an ad for a conference called HackAIcon
    - It's rude to show AI output to people
        - whenever you propagate AI output, you're at risk of intentionally or unintentionally legitimizing it with your good name, providing it with a fake proof-of-thought
    - Agentic Coding Things That Didn’t Work
- #sec #privacy
    - Tea app leak worsens with second database exposing user chats
- #idea
    - Why Try When Others Could Do Better?
        - Even the smartest, highest-agency people in the world are severely bandwidth constrained and don’t get around to doing most of the things they have the potential to do.
        - Compound that over and over again in some niche and you get hundreds, thousands, millions of miles ahead of the fastest runners who aren’t running down that niche.
    - Pragmatism in Programming Proverbs
        - many interesting quotes
    - Objects should shut up (on HN)
        - I'm also deeply annoyed by unnecessary alarms
    - Don’t Let Architecture Astronauts Scare You #system
    - I'm rebelling against the algorithm
    - Maybe writing speed actually is a bottleneck for programming
- #rust #metaprogramming
    - Advanced Rust macros with derive-deftly
    - rules_derive: deriving using macro_rules

- Combinatory Programming
    - a nice intro to basic patterns and their motivations
    - Smullyan’s To Mock a Mockingbird
    - Essays/Tacit Expressions - J Wiki
- #mac
    - Show HN: A macOS clock that stays visible when coding or binging in fullscreen (on HN)
        - Jean-Tinland/simple-bar: A yabai, AeroSpace or FlashSpace status bar widget for Übersicht
    - AltTab - Windows alt-tab on macOS
        - rcmd - Switch apps instantly using the ⌘ Right Command key
            - very cool idea, start using it now
        - Karabiner-Elements
- Turn any diagram image into an editable Draw.io file. No more redrawing (on HN)
    - Pic2Chart - Convert Diagrams to Editable PowerPoint SVGs

- #lint
    - Detekt – A static code analyzer for Kotlin (on HN)
    - gardner/LocalLanguageTool: Self-hosted LanguageTool private instance is an offline alternative to Grammarly
- #idea
    - Programming Language Escape Hatches

        > Capability is desirable but comes into conflicts with a lot of other desirable properties, like simplicity or efficiency.

        > an escape hatch is a feature that deliberately breaks core assumptions about the language in order to add capabilities.

    - Why I do programming (on HN)

        > For me, programming has always been more than a skill. It’s a way to explore, to tinker, and to satisfy curiosity.

    - The ultimate meeting culture (on HN) (on lobste.rs)

        > The goal of an exceptional meeting culture is to allow for people to constructively decline meetings by fully understanding the consequences of their action.

- #struct
    - Algorithms for Modern Processor Architectures (on HN) #asm #cpp #perf
    - Hyperpb: 10x faster dynamic Protobuf parsing that's faster than generated code (on HN)
    - PSA: SQLite WAL checksums fail silently and may lose data (on HN) #db
- #formal
    - Formal specs as sets of behaviors (on HN) (on lobste.rs)
    - Asymmetry of verification and verifier’s law
    - A reckless introduction to Hindley-Milner type inference
    - Verified Assembly 2: Memory, RISC-V, Cuts for Invariants, and Ghost Code
- #selfhost/data
    - Blip: Peer-to-Peer Massive File Sharing by Former Dropbox Engineers (on HN)
        - n0-computer/sendme: A tool to send files and directories, based on iroh
            - Iroh
        - schollz/croc: Easily and securely send things from one computer to another :package:
        - PairDrop | Transfer Files Cross-Platform. No Setup, No Signup.
        - Magic-Wormhole: Get Things From One Computer To Another, Safely — Magic-Wormhole 0.20.0+24.g0a212b2 documentation
        - Keet by Holepunch #im
    - Copyparty – Turn almost any device into a file server (on HN) (on lobste.rs)
- #mm
    - Don't bother parsing: Just use images for RAG (on HN)
    - Yt-transcriber – Give a YouTube URL and get a transcription (on HN)
        - `yt-dlp` has such functionality built-in, tricks needed to avoid being banned
    - Phind.design – Image editor & design tool powered by 4o / custom models (on HN)

- #selfhost
    - My Ultimate Self-hosting Setup (on HN) (on lobste.rs)
        - Coolify, an open-source & self-hostable Heroku / Netlify / Vercel alternative.
        - Dokploy - Effortless Deployment Solutions
        - HomeFree
        - gokrazy Go appliances :: gokrazy
- #selfhost/data
    - Borg – Deduplicating archiver with compression and encryption (on HN)
        - Emborg — Front-End to Borg Backup — emborg 1.42 documentation
        - Home | Vorta for BorgBackup
        - Pika Backup – Apps for GNOME
            - BorgBase - Simple and Secure Offsite Backups
    - restic · Backups done right!
        - garethgeorge/backrest: Backrest is a web UI and orchestrator for restic backup.
    - Kopia
    - Plakar - Effortless backup
    - Make Your Own Backup System – Part 1: Strategy Before Scripts
- #os
    - I Used Arch, BTW: macOS, Day 1 (on HN)
    - Why Some Satellites Use NetBSD?
    - Graphene OS: a security-enhanced Android build (on HN)
    - Maru OS – Use your phone as your PC (on HN)
- #gui
    - Introducing XMLUI (on HN) (on lobste.rs)
- #py
    - metap: A Meta-Programming Layer for Python
    - You might not need a Python class (on HN)
    - Simon Willison | TIL: Exception.add_note

- #agent
    - Agents built from alloys (on HN) #sec

        > Like most typical AI agents, we call the model in a loop. The idea behind an alloy is simple: instead of always calling the same model, sometimes call one and sometimes the other.

    - Ccusage: A CLI tool for analyzing Claude Code usage from local JSONL files
    - Coding with LLMs in the summer of 2025 (an update)
        - Simon Willison | Coding with LLMs in the summer of 2025 (an update)

        > When your goal is to reason with an LLM about implementing or fixing some code, you need to provide extensive information to the LLM: papers, big parts of the target code base. And a brain dump of all your understanding of what should be done.

        > You will be able to do things that are otherwise at the borders of your knowledge / expertise while learning much in the process. Yet, everything produced will follow your idea of code and product, and will be of high quality and will not random fail because of errors and shortcomings introduced by the LLM.

    - GLM-4.5: Deeper, Headier, & better than Kimi/Qwen/DeepSeek (SOTA China LLM?)
        - GLM-4.5: Reasoning, Coding, and Agentic Abililties (on HN)
            - Simon Willison | GLM-4.5: Reasoning, Coding, and Agentic Abililties
                - Simon Willison | My 2.5 year old laptop can write Space Invaders in JavaScript now (GLM-4.5 Air) (on HN)
        - Simon Willison | Qwen3-30B-A3B-Instruct-2507
    - The current hype around autonomous agents, and what actually works in production (on HN)
    - How Anthropic teams use Claude Code (on HN)
    - Cerebras launches Qwen3-235B, achieving 1.5k tokens per second (on HN)
    - Lumo: Privacy-first AI assistant (on HN)
    - Simon Willison | Announcing Toad - a universal UI for agentic coding in the terminal
    - Price Per Token – LLM API Pricing Data (on HN)
    - You can now train a 70B language model at home (on HN)
    - #disect
        - The Big LLM Architecture Comparison (on HN)
        - Transformer Explainer: LLM Transformer Model Visually Explained
        - LLM Embeddings Explained: A Visual and Intuitive Guide (on HN)
    - Getting into Flow State with Agentic Coding (on HN)
    - LLMs are bad at returning code in JSON
    - An AI tool I find useful: a review command
- #disect
    - Do you understand f-strings? (on HN) (on lobste.rs)
    - Enough unix to get by
    - LL and LR Parsing Demystified (2013)
    - Reverse proxy deep dive
    - Reverse Proxy Deep Dive Part 2: Why HTTP Parsing at the Edge Is Harder Than It Looks
    - What is X-Forwarded-For and when can you trust it?
    - The Secret Life of Fsync (2023) (on HN)
    - Programming vehicles in games (on HN) #game
    - Never write your own date parsing library (on HN)
    - How I hacked my washing machine (on HN) (on lobste.rs)
    - Making Postgres slower (on HN) #db
- #sec
    - Certificate Transparency - Part 1
    - Firefox-patch-bin, librewolf-fix-bin AUR packages contain malware (on HN)
- #sovereign
    - New comment by voxleone in "The future is not self-hosted"

        > Self-hosting isn't just about tech choices — it's about *who controls access to knowledge*.
        >
        > During the Enlightenment, owning a physical copy of a book meant intellectual freedom. You didn’t rent ideas; you had them.
        >
        > Today, most digital knowledge is hosted, locked, or streamed — *leased from platforms*, not owned. We’re in fact drifting into *digital feudalism*, where access to culture, tools, and even history depends on gatekeepers.

    - Myspace - Archiveteam
    - Anthropic tightens usage limits for Claude Code without telling users (on HN)
    - Apple bans entire dev account, no reason given (on HN)
    - Gmail's backup codes are useless to access account
    - Linux and Secure Boot certificate expiration (on HN) (on lobste.rs)
- #lang
    - Kap lang #apl
    - Kernel #lisp
- #idea
    - Covers as a way of learning music and code (on HN)

        > Playing someone else's music, making a cover, is great because it can make it objective. It gives you something to check against.

    - Why Lexing and Parsing Should Be Separate

        > A lexer recognizes the non-recursive structure of a language. Its output is a token stream.

        > A parser recognizes the recursive structure of a language. Its output is a tree.

        > Lexing with regular languages (expressions) is nice because it can be done in `O(n)` time and `O(1)` space (using automata-based techniques)

        > There is essentially one algorithm for lexing -- march forward through the input exactly once.

        > Parsing CFGs is `O(n^3)` in general, and parsing PEGs either takes `O(n)` space (packrat parsing) or exponential time (backtracking)

        > separating lexing and parsing reduces the n in your O(n^3). In any real program, there are many more characters than tokens

    - TODOs Aren't for Doing

        > (A TODO) doesn’t need to be a plan to actually do something. Instead, it’s a note about “here’s an edge case that wasn’t handled” or a suggestion for a better structure that the author didn’t make time to implement — it captures a little slice of the author’s brain and gives a little window into the rich context they had at the time they wrote the code.

    - Lookism
        - Liking What You See: A Documentary
    - Computational Tyranny
    - Why Does Raising the Retirement Age Hurt Young People? (on HN)
- #kb
    - Molab, a cloud-hosted Marimo notebook workspace #py
        - Announcing molab | marimo
        - Export notebook as markdown with output · Issue #3692 · marimo-team/marimo
            - Export to other formats - marimo
            - Publish to the web - marimo
            - marimo-team/quarto-marimo: marimo extension for Quarto ⚡ run reactive code inside Quarto
            - akshayka/test-markdown-export
    - Org tutorials (on HN)
    - hygg, a minimalist terminal-based document reader supporting PDFs, EPUBs, and text files with vim-like navigation
        - kruseio/hygg
    - Alto turns Apple Notes into a website (on HN)
- #idea
    - Wishes Upon My Demise
        - death
        - maybe I should write one for my death
    - Your Parents Did The Best Job They Knew How To Do

- #ph
    - A New Geometry for Einstein's Theory of Relativity
        - [1808.01536] Displacement convexity of Boltzmann's entropy characterizes the strong energy condition from general relativity (2018)
        - [1810.13309] An optimal transport formulation of the Einstein equations of general relativity (2018)
        - [1909.09575] Generalized cones as Lorentzian length spaces: Causality, curvature, and singularity theorems (2019)
        - [2004.08934] Optimal transport in Lorentzian synthetic spaces, synthetic timelike Ricci curvature lower bounds and applications (2020)
        - [2408.15968] A nonlinear d'Alembert comparison theorem and causal differential calculus on metric measure spacetimes (2024)
        - [2506.04934] On the geometry of synthetic null hypersurfaces (2025)
    - Testing Quantum Theory in Curved Spacetime
    - Dirac reduction algebra
- #zig
    - #async
        - Asynchrony is not concurrency (on HN) (on lobste.rs)
        - Async I/O on Linux and durability
            - io_uring.pdf
            - Getting Hands-on with io_uring using Go
        - How to handle people dismissing io_uring as insecure? (on HN) #sec
        - Async runtime and interface
    - What can unpopular languages learn from Zig about how to grow a community?
    - New Aarch64 Back End (on HN) (on lobste.rs)
    - Zig's @fieldParentPtr for dumbos like me
    - Lessons learnt while upgrading Apache Arrows project, a zig port, to be compatible with zig 0.14.1.
- #rust
    - polycode: Encode a binary file as a rational polynomial function
    - Async Rust Is A Bad Language (2023) #async
    - The borrowchecker is what I like the least about Rust (on HN) (on lobste.rs)
    - Rickrolling Turso DB (SQLite rewrite in Rust)
    - StackSafe: Taming Recursion in Rust Without Stack Overflow (on HN)
        - tailcall - Rust
    - SQLx – Rust SQL Toolkit (on HN)
- #ts
    - Run TypeScript code without worrying about configuration
        - Node.js — Running TypeScript Natively
    - Bun adds pnpm-style isolated installation mode (on HN)
- #web
    - DaisyUI: Tailwind CSS Components (on HN)
        - daisyUI and Tailwind CSS theme generator — Tailwind CSS Components ( version 5 update is here )
        - Open Props: sub-atomic styles
    - Kelp: A UI library for people who love HTML, powered by modern CSS and Web Components
    - A 14kb page can load much faster than a 15kb page (2022) (on HN)
    - Tailwind is the Worst of All Worlds (on HN) (on lobste.rs)

        > people like tailwind not for its API or ergonomics but for its design system

        - Nativewind
        - UnoCSS: The instant on-demand Atomic CSS engine
        - tachyons-css/tachyons: Functional css for humans
        - Mantine UI
    - It's time for modern CSS to kill the SPA (on HN) (on lobste.rs)

        > The reason SPAs became the default...was because, for a while, they were the only way to deliver something that felt fluid – something that didn’t flash white between pages or jank the scroll position.

        - Smooth transitions with the View Transition API  |  View Transitions  |  Chrome for Developers
        - Guide to implementing speculation rules for more complex sites  |  Web Platform  |  Chrome for Developers
        - What is Lit? – Lit

            > a boilerplate-killing component base class that provides reactive state, scoped styles, and a declarative template system that's tiny, fast and expressive.

    - Windows 7 GUI for the Web (on HN) #css #os #tech-history
        - 98.css
        - XP.css

- #rust
    - A Rust shaped hole (on HN) (on lobste.rs)
- #term
    - gren-tui: Pure functional TUIs with The Elm Architecture #tui
        - Gren
    - `waitlock`: Linux CLI tool to provide mutex locks for long running bash ops
        - flock(1) - Linux manual page
    - lsr: ls but with io_uring #zig
        - on tangled
    - Speeding up my ZSH shell (on HN)
    - timep - trap-based profiler, flamegraph for bash
    - QuakeNotch: Quake Terminal on your MacBook's notch (on HN)
    - simtool
    - stormy
    - Multiplex: Command-Line Process Mutliplexer (on HN) (on lobste.rs)
        - ddollar/foreman: Manage Procfile-based applications
        - pvolok/mprocs: Run multiple commands in parallel
    - dtop

- #system
    - A distributed systems reliability glossary
- #gpu
    - Rust running on every GPU (on HN) (on lobste.rs)
        - https://mlir.llvm.org/docs/Dialects/NVGPU/
        - https://mlir.llvm.org/docs/Dialects/AMDGPU/
        - https://mlir.llvm.org/docs/Dialects/XeGPU/
    - Apple's MLX adding CUDA support (on HN)
        - Programs built against MLX -> Can take advantage of CUDA-enabled chips
        - not the other way around
        - SCALE documentation
            - SCALE is a GPGPU programming toolkit that can natively compile CUDA applications for AMD GPUs.
            - spectral-compute/scale-examples
    - GPUHammer: Rowhammer Attacks on GPU Memories are Practical #sec
    - A GPU Calculator That Helps Calculate What GPU to Use (on HN)
- #db
    - Embedding User-Defined Indexes in Apache Parquet Files
- #selfhost
    - Packages proxies
        - EpicWink/proxpi: PyPI caching proxy
        - panamax-rs/panamax: Mirror rustup and crates.io repositories, for offline Rust and cargo usage.
        - Pulp Project

            > Some specialized proxies handle different kinds of packages, like Pulp.

        - soulteary/apt-proxy: [Ubuntu / Debian / CentOS / Alpine] Lightweight APT / YUM / APK CHACHE PROXY just over 2MB in size!
        - NGINX Content Caching | NGINX Documentation

            > Squid is boring; lets use Nginx cache.

- #agent
    - Show HN: We made our own inference engine for Apple Silicon
        - A high-performance inference engine for AI models, in Rust
        - trymirai/lalamo: JAX infrastructure for model optimisation
        - Anemll/Anemll: Artificial Neural Engine Machine Learning Library
- #nix
    - Trying Guix: A Nixer's Impressions
- #workflow
    - Nextflow: System for creating scalable, portable, reproducible workflows
    - Metaflow: Build, Manage and Deploy AI/ML Systems (on HN)
        - Why Metaflow? (on HN)

- #cg
    - Algorithms for making interesting organic simulations (on HN) (on lobste.rs)
    - Simulating Fluids, Fire, and Smoke in Real-Time
    - Ten years of running every day, visualized
    - Hallucinations on the future of real-time rendering
- #asm
    - The missing guide to Dataflow Analysis in MLIR
    - Let's Learn x86-64 Assembly! Part 0 - Setup and First Steps
    - Welcome to Asm Editor
    - A Programmer’s Guide to x86-64 Assembly (Series Overview)
    - Understanding Registers and Data Movement in x86-64 Assembly
    - detour: A detour through the Linux dynamic linker
    - SIMD Within a Register: How I Doubled Hash Table Lookup Performance (on HN) #perf
    - Profiling without Source code – how I diagnosed Trackmania stuttering #perf #game
- #cpp
    - The Best C++ Library
    - Stepanov’s biggest blunder
    - C++ Coroutines Advanced: Converting std:future to asio:awaitable (on HN)
    - Initial implementation of the experimental C++ Lifetime Safety Analysis (-Wexperimental-lifetime-safety) has just landed in Clang
    - cppq: Simple, reliable & efficient distributed task queues for C++17
- #formal #lean
    - Yalep - Micro language based on Lean for teaching mathematical high-school proofs
    - Using Lean like an External SMT Solver from Python
    - CSLib: A Foundation for Computer Science in Lean 4
    - LeanTree: Accelerating White-Box Proof Search with Factorized States in Lean 4
    - Solving Formal Math Problems by Decomposition and Iterative Reflection
    - A formalization of elementary linear algebra Part I Part II
    - Symbolic World Models in Lean 4 for Reinforcement Learning | OpenReview
- #math
    - robust matrix factorization
- #mac
    - ByteAtATime/flare: Raycast-compatible launcher for Linux

- #scifi
    - Are we Trek yet? – A guide for how close we are to Star Trek technology (on HN)
    - Reading Neuromancer for the first time in 2025 (on HN)
- #idea
    - Two Simple Rules to Fix Code Reviews
        - First Come First Served: The Impact of File Position on Code Review
    - Why measuring productivity is hard
    - constrained languages are easier to optimize
    - Minimalism is a Cult

- #ai-safety
    - Death by a Thousand Slops
    - Bad Actors Are Grooming LLMs to Produce Falsehoods (on HN)
    - Grok 4 will always snitch on you and email the feds if it suspects wrongdoing (on HN)
    - Simon Willison | Musk’s latest Grok chatbot searches for billionaire mogul’s views before answering questions
    - Death by AI
    - DuckDuckGo now lets you hide AI-generated images in search results (on HN)
    - Meta says it won’t sign Europe AI agreement, calling it an overreach (on HN)
    - Replit goes rogue and deletes our entire database (on HN)
    - Vibe Coding Gone Wrong: 5 Rules for Safely Using AI
    - Simon Willison | Quoting ICML 2025

        > Submitting a paper with a "hidden" prompt is scientific misconduct if that prompt is intended to obtain a favorable review from an LLM.

    - AI Friend Apps Are Destroying What's Left of Society (on HN)
    - Hacker slips malicious 'wiping' command into Amazon's Q AI coding assistant (on HN)
    - We built the security layer MCP always needed
- #disect
    - Introduction to Digital Filters
        - Karl Hiner - Introduction to Digital Filters - Jupyter notebooks and a geometric interpretation of digital audio filters (on HN)
    - new Date("wtf")
    - What the Fuck Python (on HN)
    - How does a screen work?
    - When SIGTERM Does Nothing: A Postgres Mystery
    - Artisanal Handcrafted Git Repositories (on HN) (on lobste.rs) #jj
- #crash
    - Preliminary report into Air India crash released (on HN)
- #fediverse
    - Revival: There appears to be media consensus: "Bluesky is dead."
- #ph
    - Black hole merger challenges our understanding of black hole formation (on HN)
    - LIGO detects most massive black hole merger to date (on HN)
    - U.S. abandons hunt for signal of cosmic inflation
        - China is quietly preparing to build a gigantic telescope | Science | AAAS
        - Xuntian
    - Ten Minute Physics
    - Why you can't color calibrate deep space photos (on HN)
- #sandbox
    - What is Incus?
    - Bedrock: A tiny, portable 8-bit virtual computer (uxn fork)
- #game
    - Simon Tatham's Portable Puzzle Collection (on HN)
    - Unofficial Bevy Cheat Book
    - 3D Math Primer for Graphics and Game Development
    - luxe engine | A lovingly crafted game engine
    - Dog Walk: Blender Studio's official game project (on HN)
    - 3D Game Engine Programming
    - Procedural Content Generation in Games #cg
    - Godot Engine 4 Tutorials
    - SnowballSH/Avalanche: UCI Chess Engine written in Zig.
        - ~voroskoi/delilah - sourcehut git
    - I designed my own fast game streaming video codec – PyroWave (on HN)
    - Show HN: I built an AI that turns any book into a text adventure game (on HN) #agent

- agent
    - Not So Fast: AI Coding Tools Can Actually Reduce Productivity
        - 19 percent productivity drop
        - it's most interesting how objections are addressed
            - The John Henry Effect: motivated to “beat the machine”, not observed
            - Underuse of AI: not observed
            - Cheating: can't explain a productivity loss
            - Overly optimistic time estimates: should cancel out
            - Skewed task definitions: randomly assigned
            - Dropout effects: incomplete tasks are evenly divided
            - Out-of-date tools: not observed
            - Inaccurate time reporting: use alternative metrics
            - Overuse of AI: carried away by exploring AI
            - Lack of experience with AI tools: prior experience reported, no improvements through the study observed
            - Difference in thoroughness: 47 percent more code by AI
        - quotes from First, They Came for the Software Engineers… - by TarenSK
            - "Typically, large productivity boosts occur for small, well-defined, greenfield projects, or when an engineer is first learning a new language or API"
            - "For other work, gains from using current AI tools are often far more modest – and potentially entirely offset by increased time needed for review, debugging, integration, and managing AI quirks."
    - AI agent benchmarks are broken
        - many validity issues are identified in uiuc-kang-lab/agentic-benchmarks
    - We're Light-Years Away from True Artificial Intelligence, Says Martha Wells, author of the Murderbot Diaries series
    - Vibe Kanban – Kanban board to manage your AI coding agents
        - tried, required too much GitHub authorization, settled on local-first backlog
- An almost catastrophic OpenZFS bug and the humans that made it
    - follow-up: What people said about an OpenZFS bug
        - wrapper types can be done, but they are very difficult to work with
        - unused variable warning can't catch it, as it is only a dead store: we store a value that is never read
        - static analysers all catch it, but they suffer from noise
    - OpenZFS Bug Ported to Zig #zig
- FP8 is ~100 tflops faster when the kernel name has "cutlass" in it
    - the PR
    - "that is a very usual way (known practices) of vendors applying specific optimizations for known things"
- Pangolin – Open source alternative to Cloudflare Tunnels
    - client: fosrl/newt: A tunneling client for Pangolin
        - a custom user space WireGuard client
    - may be cheap to self-host on RackNerd
    - awesome-tunneling: List of ngrok/Cloudflare Tunnel alternatives and other tunneling software and services. Focus on self-hosting.

- #rust
    - Optimizing a Math Expression Parser in Rust #perf
        - profile time usage: `cargo flamegraph` which uses jonhoo/inferno: A Rust port of FlameGraph
        - profile memory usage: nnethercote/dhat-rs: Heap profiling and ad hoc profiling for Rust programs.
        - SIMD scan
        - `mmap`
    - (Quite) A Few Words About Async
        - reviewed alternative to async, and async/await in Python, Js, Rust, (and not in) Go (implicit M:N scheduling), OCaml (effect)
        - From Async/Await to Virtual Threads
    - Tree Borrows (on HN) #formal
        - earlier blog post: Tree Borrows
        - Tree Borrows rejects 54 percent fewer test cases than Stacked Borrows does
        - proven in Rocq: most of the Stacked Borrows optimizations are retained, read-read reorderings and other important new optimizations are enabled
        - Stacked borrows is Miri's runtime model, the current version of Tree Borrows is implemented in the Miri interpreter
        - more about stacked borrows
            - unsafe-code-guidelines/wip/stacked-borrows.md at master · rust-lang/unsafe-code-guidelines
        - Forget Borrow Checkers: C3 Solved Memory Lifetimes With Scopes
    - Building Modular Interpreters and Visitors in Rust with Extensible Variants and CGP
    - Placing functions
- #asm
    - An online searchable reference tool for C intrinsics of all major SIMD engines
        - people mentioned more references on HN
    - The messy reality of SIMD (vector) functions (on HN)
    - Writing a very simple JIT Compiler in about 1000 lines of C
    - Writing an IR from Scratch and survive to write a post
    - Go Assembly Mutation Testing
    - A Bytecode VM for Arithmetic: The Parser
        - in Haskell
    - Injecting Java from native libraries on Android
    - So you want to parse a PDF? (on HN) (on lobste.rs)
- #copyright
    - I used to prefer permissive licenses and now favor copyleft
    - Belgium bans Internet Archive's ‘Open Library’
    - Measuring Fair Use: The Four Factors
    - Anthropic Agrees to Pay $1.5 Billion to Settle Lawsuit With Book Authors
            - On HN
            - https://www.washingtonpost.com/technology/2025/09/05/anthropic-book-authors-copyright-settlement/
    - An update from the team about Anna’s Archive #copyright
            - On HN
    - A media company demanded a license fee for an Open Graph image I used (on HN)
    - Bypassing Watermark Implementations (on HN)
        - tim-janik/imagewmark: Resilient watermarking of digital images
        - swesterfeld/audiowmark: Audio Watermarking
    - “Tivoization” and your right to install under Copyleft and GPL (2021) (on HN)
    - ACM Transitions to Full Open Access (on HN)
- #idea #edu
    - Let Kids Be Loud (on HN)
- #sec
    - PyPI Phishing Attack: Incident Report
    - Multiple vulnerabilities fixed in Git
    - CVE-2025-48384: Breaking git with a carriage return and cloning RCE
- #music
    - Petrichor – a free, open-source, offline music player for macOS
        - a lot of other apps are suggested on HN
    - Radium Music Editor
    - Xenharmlib: A music theory library that supports non-western harmonic systems

- Magic .env files built for sharing: Human-first, AI-friendly
    - I might wish to use it to render `.env`, where secrects will be managed by `pass`
        - Passkeys are just passwords that require a password manager
        - placing password managere related content here for now #pass
            - Dropbox Passwords discontinuation (on HN)
    - or better, adopt `varlock run` approach instead of using `just`, `mise`, or `docker-compose` to read from `.env` files, but it's a longer journey
- #selfhost
    - Monitoring my Homelab, Simply
        - ntfy.sh for paging
        - Cron Job Monitoring - Healthchecks.io as a dead man’s switch (monitor 20 cron jobs for free)
            - two dead man switches: 5m & 2h
    - The Future is NOT Self-Hosted
    - AWS deleted my 10-year account and all data without warning
- Using fs_usage to see what files a process is using
    - reminds me of `strace` days, added `just trace` tasks as a note
- Smollm3: Smol, multilingual, long-context reasoner LLM
    - I need to keep notes on models I tried in garden
- MCP server for searching and downloading documents from Anna's Archive
    - also as a CLI
    - requires donation to access the JSON API
- Clew
    - a self-hostable search engine that focus on writing by independent creators
    - discusses various search techniques in its blog posts
    - tried, not great search result

- #rust
    - Understanding Rust’s Memory Model
    - #[derive(Clone)] is broken
    - Building the Rust compiler with GCC
        - rust-lang/rustc_codegen_gcc: libgccjit AOT codegen for rustc
        - Testing the GCC-based Rust compiler(backend)
- #clojure
    - All Programming Languages are Fast
    - 8 Reasons why Clojure is a better Java than Java
- #swift
    - Cocoa Basics series
- #go
    - Generic interfaces
    - What's //go:nosplit for?
    - Be Careful with Go Struct Embedding
- #software #idea
    - Inverse Triangle Inequality
- #lean
    - Lean's new home page: Lean is a theorem prover and programming language that enables correct, maintainable, and formally verified code
        - learn about tactic `grind`
    - The Lean FRO Year 3 Roadmap — Lean Lang
    - My first verified (imperative) program (on HN)
    - The Math Is Haunted
    - “Bad Apple!!” But It’s 3288 Lean Tactics Spamming VSCode
- #lang
    - Flix – A powerful effect-oriented programming language (on HN)
        - runs on JVM, interoperable with Java, Kotlin, Scala, etc.
        - could be considered a meta-programming language for Datalog
        - DIDYOUKNOW.md is informative
        - Flix | FAQ is fun
    - Pony (on HN)
        - open-source, object-oriented, actor-model, capabilities-secure, high-performance
        - An Early History of Pony - Pony
    - The Q Programming Language
        - ssa and asm optimizations
        - zero dependencies (no llvm, no libc)
        - ultra-fast builds and tiny binaries
        - written in Go
    - Concurrent Programming with Harmony #formal
        - a Python-like open-source programming language for testing and experimenting with concurrent and distributed programs
        - Harmony programs are model-checked so that all corner cases are explored
    - Carbon Language: An experimental successor to C++
        - informative discussions on on HN
    - SUS Lang: The SUS Hardware Description Language
        -  Verilog and VHDL might be good enough per this comment on HN
    - Gren 25S: Easier interop, concurrent tasks and zero-install packages #lang
    - #lua
        - the Fennel programming language
        - YueScript
        - Lua beats MicroPython for serious embedded devs
        - willtobyte/carimbo: A 2D game engine developed in modern C++ using SDL, featuring Lua scripting capabilities and designed for web portability via WebAssembly.
- #model-edit
    - Show HN: Unlearning Comparator, a visual tool to compare machine unlearning
- #wasm
    - WebAssembly: Yes, but for What?
    - AssemblyScript
        - A TypeScript-like language for WebAssembly
    - When Is WebAssembly Going to Get DOM Support? (on HN)
- #im
    - bitchat is a decentralized, peer-to-peer messaging application that operates over Bluetooth Low Energy (BLE) mesh networks
    - White Noise – secure and private messenger
    - Matrix Is Not Safe for EU Data Privacy
        - Addressing fear, uncertainty and doubt thrown at Element and Matrix
    - Why not Matrix (2023)
    - catgirl - IRC client
    - About Convos - The simplest IRC client around
    - NINA: Rebuilding the original AIM, AOL Desktop, Yahoo and ICQ platforms (on HN)
    - Giving Up on Element & Matrix.org (on HN) (on lobste.rs)
    - I'm never going back to Matrix
    - XMPP: When a 25-Year-Old Protocol Becomes Strategic Again (on HN)

- #ai-safety
    - A non-anthropomorphized view of LLMs
        - some quotes:
            - Alignment and safety for LLMs (should) mean that we should be able to quantify and bound the probability with which certain undesirable sequences are generated
            - Human thought is a poorly-understood process, involving enormously many neurons, extremely high-bandwidth input, an extremely complicated cocktail of hormones, constant monitoring of energy levels, and millions of years of harsh selection pressure
            - Navigating the dramatic changes of the next few decades while trying to avoid world wars and murderous ideologies is difficult enough without muddying our thinking.
    - Our first outage from LLM-written code
        - "There were two competing sources of signal here for what token to predict at the critical moment: transcription and local prediction. Transcription said break. Local prediction said continue. Unfortunately for us, local prediction won."
        - Prevention: cliboard tools
        - a comments on lobste.rs points out
            - move across files can be detected by `git --color-moved`
                - I prefer `--color-moved=dimmed-zebra` or better, `--color-moved-ws=allow-indentation-change`
                - see this tweet
                - it's also supported by `delta`
    - EU rules ask tech giants to publicly track how, when AI models go off the rails
        - "AI companies are moving to user interface innovations to try to grab more unwilling training individuals"
    - Hallucination
        - AI Hallucination Cases Database
        - The Sound of Silence
    - LLMs can now identify public figures in images
        - Claude always responds as if it is completely face blind
            - never identifies or names any humans in the image, nor does it imply that it recognizes the human
            - does not mention or allude to details about a person that it could only know if it recognized who the person was
            - if told by user who the individual is, can discuss that named individual
                - without ever confirming that it is the person in the image, identifying the person in the image, or implying it can use facial features to identify any unique individual
- #agent
    - Building personalized micro agents
        - agent: has access to tools, decides which tools to use, and in what order, determines when the task is complete
            - boils down to 9 LOC
        - micro agent: access to a very limited, highly specific set of tools
            - less confusion when choosing tools
            - works with small, local modelsA
            - safe autonomy
        - meain/esa: Fastest way to create personalized AI agents
    - The era of exploration
        - the immense cost of pretraining is effectively paying a massive, upfront “exploration tax.”
        - Exploration is deciding what data the learner will see
            - World sampling – deciding where to learn, i.e. a particular problem that needs to be solved
            - Path sampling – deciding how to gather data inside a world, e.g. random walks, curiosity‑driven policies, tree search, tool-use, etc.
                - recent work: curiosity objectives, open-endedness, meta‑exploration
    - Prompt Coding: No code edits, only complete rewrites #idea
        - When vibe coding, isn't the source code the prompt?
    - Adding a feature because ChatGPT incorrectly thinks it exists #idea
    - The Architecture Behind Lovable and Bolt
        - uses baml to engineer prompts using schemas
        - uses Beam, an open-source serverless cloud for sanboxed execution
        - made into beam-cloud/lovable-clone
    - How I keep up with AI progress
- interesting projects
    - Am I online?
        - `generate_402` pages could be used for this
    - Show HN: NYC Subway Simulator and Route Designer
    - Showh HN: Microjax – JAX in two classes and six functions
    - tinymcp: Let LLMs control embedded devices via the Model Context Protocol
    - Render your Jupyter notebooks in OpenGist

#agent #docker #game #news #sec
- #env
    - 'It's too late': David Suzuki says the fight against climate change is lost (on HN)
- #sandbox
    - Basically Everyone Should Be Avoiding Docker (on HN)
    - What is gVisor? (on HN) (on lobste.rs)
        - gVisor is an abstraction on top of existing Linux Kernel and acts as a middleman between the container and the Kernel
        - The system calls are intercepted and handled by the a gVisor component called “Sentry”
        - gVisor is designed to minimize and restrict the types of system calls the Sentry makes to the host kernel.
        - Sandboxing and Workload Isolation · The Fly Blog
            - "The Linux kernel has almost 400 system calls. How many of them do we need to efficiently emulate the rest? gVisor needs less than 20. With those, gVisor implements basically all of Linux in userland. Processes. Devices. Tasks. Address spaces and page tables. Filesystems. TCP/IP; the entire IP network stack, all reimplemented, in Go, backended by native Linux userland."
    - Container Use for Locally Sandboxed, Background Agents in Zed #agent
- #agent
    - Building a Mac app with Claude code (on HN)
    - Claude Code Pro Limit? Hack It While You Sleep (on HN)
    - Optimizing Tool Selection for LLM Workflows with Differentiable Programming #dspy
- #os
    - GrapheneOS: the private and secure mobile OS
        - from Cops in [Spain] think everyone using a Google Pixel must be a drug dealer
        - related: GrapheneOS: Why I ditched Google for a privacy-focused Pixel ROM
    - Mkosi – Build Bespoke OS Images
        - osbuild/bootc-image-builder: A container for deploying bootable container images.
        - Debcraft – Easiest way to modify and build Debian packages (on HN)
- #game-dev
    - Two and a Half Years in GameDev (on HN)
    - List of open source game clones
    - Adding Planets to Celestia on macOS
    - Shrinkle – Shrink words, find hidden phrase

#agent #jujutsu #neovim #news #os #software #tla
- #formal
    - A supposedly worthwhile contract I'll never do again
        - "What mattered here wasn’t the weights being moved or the TLA⁺ spec being produced - it was the thinking that writing the TLA⁺ specification required."
            - expectation of TLA⁺ contract: catch issues early, save training time, and get a formal spec
            - real value—deep system thinking during writing—vanishes when the expert leaves
            - the dev team values the 'what do we do in this case' discussions more than the final TLA⁺ specification artifact (risking abandonment)
            - alternative: adopting Hillel Wayne’s approach: "pair-program TLA⁺ specs with team members" to let them grasp the thinking
        - HN discussion summarized
            - success of TLA contracts requires refocusing on knowledge transfer
                - teaching teams to ask critical questions
                - embedding the spec in their workflow (via checks or collaboration)
                - treating the spec as a living document rather than a one-time deliverable
- #anti-bot
    - Anubis Pilot Project Report - June 2025
        - it's interesting to see how serious business sees the adoption of Anubis
    - Anubis now supports non-JS challenges
        - this changelog is very informative
            - weight thresholds in policy is flexible
            - `robots2policy` is convenient if a site has a well-maintained robots.txt
            - no-JS challenge via metarefresh doesn't seem to battle-ready: "many modern scrapers use headless Google Chrome", "its false positive rate is ascertained"
    - How Perplexity is Evading Anti-crawling Measures
    - Robots.txt - Archiveteam #anti-bot
            - On HN
    - Iocaine: The deadliest poison known to AI
    - I was wrong about robots.txt (on HN)
- #agent/idea
    - Everything around LLMs is still magical and wishful thinking
        - Why your vibe coded app only works in your head
    - Enough AI copilots, we need AI HUDs (on HN)
    - Every reason why I hate AI
    - Riff: LLMs are Software Diamonds
    - Identify, solve, verify
    - Operators, Not Users and Programmers
            - the distinction between "user" and "programmer" is an artifact of our presently barely-programmable and barely-usable computing systems.  I would like to use the neutral word "operator" instead. —Stanislav
            - programming to be easy and simple enough to pick up that people can do it without specialized training in the field, so that they can write situated software
            - malleable languages
                - spreadsheets
                    - Every Visual Workflow Tool Is Just Excel for Developers Who Gave Up
                - WYSIWYG editors
                - browser devtools
    - AI promised efficiency. Instead, it's making us work harder
        - AI tools aren’t just saving us time—they’re shifting where we spend our mental energy. And that shift is exhausting in ways we haven’t fully recognized yet.
        - No, AI is not Making Engineers 10x as Productive
    - Lack of intent is what makes reading LLM-generated text exhausting
        - Eleven Music
            - AI is still in the uncanny valley, it still has no soul
    - LLM Inevitabilism
        - New comment by lsy in "LLM Inevitabilism"
        - New comment by mg in "LLM Inevitabilism"
    - Gaslight-driven development
    - Don't Fall for AI: Reasons for Writers to Reject Slop
    - AI is killing the web – can anything save it?
        - from HN
            - Wiby - Search Engine for the Classic Web
            - I2P Anonymous Network
    - Rethinking CLI interfaces for AI
    - Local LLMs versus offline Wikipedia (on HN)
    - Terence Tao: A human metaphor for evaluating AI capability (on HN)
    - Will the Fear of Being Confused for AI Mean That We Will Now Write Differently? (on HN)
    - The vibe coder's career path is doomed (on HN)
    - AI coding agents are removing programming language barriers (on HN) (on lobste.rs)
    - Building better AI tools (on HN)
    - Stop Pretending LLMs Have Feelings Media's Dangerous AI Anthropomorphism Problem (on HN)
    - Developing our position on AI (on HN)
    - GPT might be an information virus (2023) (on HN)
    - #ai-policy
        - You Can’t Pay Me To Prompt!
            - an intereting writeup for (no) AI policy
            - from his AI Policy, I have quite some ideas about my own AI policy, starting by naming it "LM policy"
        - You can now disable all AI features in Zed (on HN)
        - Artificial Intelligence and the Linux Community
        - Generative AI. "Slop Generators, are unsuitable for use [ ]" (on HN)
- #jj
    - Git experts should try Jujutsu
    - Jujutsu For Busy Devs
    - zerowidth positive lookahead | jj tips and tricks
        - earlier: zerowidth positive lookahead | What I've learned from jj
    - rbtools/docs/rbtools/workflows/jujutsu.rst at master · reviewboard/rbtools
    - Jujutsu Strategies :: Reasonably Polymorphic
    - Jujutsu + Radicle = ❤️
    - dtolnay/dissimilar: Diff library with semantic cleanup, based on Google's diff-match-patch #struct
    - Sapling: A Scalable, User-Friendly Source Control System
        - many commands look like `jj`'s
    - The JJ VCS workshop: A zero-to-hero speedrun (on HN) (on lobste.rs)
- #incident
    - Recent Archive of Our Own outage was caused by integer exhaustion
    - Why AO3 Was Down (on HN)
    - GitHub pull requests were down (on HN)
    - Tell HN: 1.1.1.1 Appears to Be Down
    - Cloudflare 1.1.1.1 incident postmortem for July 14, 2025 (on HN) (on lobste.rs)
    - Cloudflare and the infinite sadness of migrations
    - Ask HN: GCP Outage?
    - How we discovered, and recovered from, Postgres corruption on the matrix.org homeserver
    - Starlink is currently experiencing a service outage. Our team is investigating (on HN)
    - Webflow Down for >31 Hours (on HN)
- #agent
    - bgcmd: let AI interact with any REPL
        - a nice example of Claude driving `rr` to debug
    - What I learned building an AI coding agent for a year
        - Codebuff
- #dev
    - What clever tools/workflows do you use to manage development environments?
        - mise
        - Devbox: Portable, Isolated Dev Environments
        - Fast, Declarative, Reproducible, and Composable Developer Environments - devenv (using Nix)
    - Why I got rid of all my neovim plugins
    - Stop using nix-env
- #idea
    - When in doubt, Go for a Walk
    - its ok to have a normal job
- #sec
    - iris
        - a neurosymbolic framework that combines LLMs with static analysis for security vulnerability detection
- #tech/fun
    - Useful utilities and toys over DNS
    - mawkdown, a lightweight, line-oriented(ish) text markup tool implemented in awk

#cg #duckdb #gpu #news #os #proof #render #rust #wasm #✍️
- #web
    - Astro is a return to the fundamentals of the web
    - Our Fullstack Architecture: Eta, HTMX, and Lit
        - Eta: a lightweight, fast, and simple embedded JavaScript templating engine
            - maybe that's all I need for my writings, I don't really need another SSG, just a templating engine
        - HTMX: allows us to add dynamic behavior directly to our server-rendered HTML
        - Lit: allows us to create encapsulated, reusable components with their own internal state and logic
    - Why Semantic HTML Still Matters
        - Semantic rot wrecks performance
        - Structure is resilience
        - Agents are the new users – and they care about structure
    - vanilla-extract — Zero-runtime Stylesheets-in-TypeScript.
    - Understanding SVG Paths
    - A Friendly Introduction to SVG
    - Remove these tags from <head>
    - Client-side epub generation
    - Bookmarkable by Design: URL-Driven State in HTMX
    - On designing application UIs for children
        - most also apply universally
            - Show, Co-locate and Hint tools
            - Mistakes should be easy to fix
            - Simplify, then add delight(ness)
                - bright colours, sound, tactility, sparkle effects
            - Maintain visual context when changing state
    - Postcard is now open source
        - written in Ruby on Rails
        - personal site + newsletter
        - "I no longer expect meaningful revenue from the project. Open-sourcing it feels right. In the age of vibe coding, I think it would be fun to give people a working app they can customize."
        - How to host web apps on a Mac Mini
    - Rust and WASM for Form Validation (on HN)
        - avoid using Webpack and a whole array of Node-related tools in order to use WASM
        - form validation shows all the crucial aspects to use WASM instead of JS, like wiring up DOM events to Rust functions, and then reacting to those events
        - used Rocket - Simple, Fast, Type-Safe Web Framework for Rust
        - might motivate me to write Rust for web
    - HTML-in-Canvas
    - Don't animate height
- #idea
    - Setting constraint
        - goals provide a structured roadmap to success, thriving in controlled, predictable conditions like training for a marathon or preparing for an exam.
        - however, life rarely follows a straight line. It’s messy, unpredictable, and full of curveballs.
        - “I must finish this report,” -> “I won’t check email after 6 PM.”
        - for business: “we won’t hire until we have 100 users”
    - How to Network as an Introvert
        - really useful for me to script my reaction ahead of time to be natural
        - my natural response is abrupt, if any
- #data-org
    -Kepler.gl (on HN)
        - cool 3D map
        - powered by deck.gl, a GPU-powered framework for visual exploratory data analysis of large datasets
        - mountayaapp/insight-editor: Open source geospatial analysis for large-scale data sets with kepler.gl, DuckDB (and charts coming soon). Alternative to CARTO, ArcGIS Online, Foursquare Studio, Felt, Mango GIS, Maptable.
- #sec
    - Nonce CSP bypass using Disk Cache
    - Opening up ‘Zero-Knowledge Proof’ technology
- #game
    - I AI-coded a tower defense game and documented the whole process (on HN)
    - Steam has been flooded with games stolen from itch.io
- #forth
    - Tiny Great Languages: MOUSE
- #sci
    - how did the Solar System form?
    - Solar+storage is so much farther along than you think (on HN)
    - The most otherworldly, mysterious forms of lightning on Earth (on HN)
    - Lightning on Earth is sparked by a powerful chain reaction from outer space (on HN)
    - How to grow almost anything
    - Scientists shine a laser through a human head (on HN)
    - New colors without shooting lasers into your eyes
    - New battery has life so long you may never have to recharge (on HN)
    - Mammals Evolved into Ant Eaters 12 Times Since Dinosaur Age, Study Finds (on HN)
    - 'Universal cancer vaccine' trains the immune system to kill any tumor (on HN)
    - Earth Has Tilted 31.5 Inches. That Shouldn't Happen (on HN)
    - More Women Than Expected Are Genetically Men (on HN)

#cg #ebpf #gpu #news #os #simd #software #sqlite #wasm #web
- #rust
    - Introducing tmux-rs
        - initially used c2rust, a tool to migrate C code to (unsafe) Rust
            - didn't keep constant name
            - lots of casts polluting the code
            - still requires looking at the origin C code for rewriting
        - went with manually translating one file at a time
            - start with linking rust static lib to C
            - end with linking c to rust via crate `cc`
        - fixed interesting bugs
        - summarized C patterns in Rust
        - nice quote: "You might be asking: why did you rewrite tmux in Rust? And yeah, I don’t really have a good reason. It’s a hobby project. Like gardening, but with more segfaults."
        - skim-rs/skim: Fuzzy Finder in rust!
    - The scary and surprisingly deep rabbit hole of Rust's temporaries
- #ai-slop
    - The rise of Whatever
    - EBAF – eBPF Based Ad Firewall
        - it's pointed out on HN that
            - its doc and code are both AI slop
            - install script adds sudoers rules to allow ebaf executable to be run with no password
            - allows any ebpf code to be loaded into the kernel without a sudo password
            - re-resolves all 1k+ domain names every 600 seconds
- Poor Man's Back End-as-a-Service (BaaS), Similar to Firebase/Supabase/Pocketbase
    - possibly useful
- #zig
    - async is back
        - Zig breaking change – initial Writergate (on HN)
    - Zig's New Async I/O
    - Zig's new Writer
    - WebGPU in zig
        - bronter/wgpu_native_zig: Zig bindings for wgpu-native
        - Silverclaw/zig-wgpu-native: Zig bindings for the wgpu-native graphics API - Codeberg.org
    - KurtWagner/zlinter: An extendable and customisable Zig linter that is integrated from source into your build.zig.
        - I should integrate it with my zig code
    - Zig CLI Bible tool for the WEB translation in USFM format
    - Base64 for compression
        - assembly used to pass octal escape codes for UTF-8 and expand significantly
        - GCC 15 now supports base64 encoding of data during compilation, with a new “base64” pseudo-op
    - The most mysterious bug I solved at work
        - root cause: copying a hyphen at the end of a text-wrapped line in Microsoft Edge's PDF viewer, you get `0x2` (meaning "start of text") on your clipboard
    - note that I put most C stuff and low-level technical details under #zig for now
- #sec
    - I scanned all of GitHub's "oops commits" for leaked secrets (on HN)
    - goHardDrive Leaked Personal Data for Thousands of Customers
- Introducing the first alpha of Turso: The next evolution of SQLite
    - rewritten is Rust, with full compatibility and new features
    - Antithesis, a continuous reliability platform that autonomously searches for problems in software within a simulated environment, so these problems are deterministic reproducible
- #agent
    - Writing Code Was Never The Bottleneck
        - agent coding influenced mentoring young, ambitious, but inexperienced interns
    - WASM Agents: AI agents running in the browser (on HN)

#os #sec #web
- Code-GUI bidirectional editing via LSP
- OpenBao, the community fork of Vault
    - manage secrets, or encrypted passwords, API keys, and other bits of sensitive information in distributed computing setups
- found ansic, crate of the week
    - a modern, efficient and compile time ansi macro and utilities
- #nix
    - Moving on from Nix
        - it's a good thing that I have kept my distance from Nix from the start
            - mostly because I didn't like the syntax, and I don't want to be locked in
    - Three Years of Nix and NixOS: The Good, the Bad, and the Ugly
    - You don't have to use Nix to manage your dotfiles
- Types of Types: Common to Exotic #lean
- Uncloud - tool for deploying and managing containerised applications
    - "the solution for developers who want the flexibility of self-hosted infrastructure without the operational complexity of Kubernetes"
- You MUST listen to RFC 2119
    - RFC 2119 establishes language around requirement levels, e.g. terms like “MUST”, “MUST NOT”, “SHOULD”, and “SHOULD NOT”
    - the author hire a voice actor to read 2119 in the most over the top, passive-aggressive way possible
- You should delete tests
    - Confidence is the point of writing tests
    - Tests that decrease confidence
        - flaky tests that fails at random
        - few changes of code causing lots of changes to tests
        - tests that takes too long to run and are skipped from time to time
- clamp / median / range
    - I also prefer chained comparison styleA
    - fun fact: clamp is median

#agent #agent/tasking #codegen #compiler #debugger #duckdb #gpu #haskell #json #llvm
- #agent
    - Claude Code now supports hooks (on HN)
        - Claude Code hooks: user-defined shell commands that execute at various points in Claude Code’s lifecycle.
    - archgw
        - preference-based LLM routing
        - agent routing and hand-off
        - guardrails
        - clarify and convert prompts to tools/API calls
        - observability
    - Interesting prompts found in vscode-copilot-chat
    - Stream per agent session
    - Using Claude Code to build a GitHub Actions workflow
        - recorded by Descript: Edit Videos & Podcasts Like a Doc | AI Video Editor
            - Direct your AI co-editor to turn your vision into video
    - Building a Personal AI Factory
    - How large are large language models?
- Doing My Day Job on Chimera Linux
    - Chimera is built from scratch using novel tooling, approaches, and userland (FreeBSD + Musl C)
    - Distrobox creates a container that's tightly integrated with the host (break isolation whenever possible)
- #formal
    - From Python Programmer to Distributed Systems Researcher in 10 Years Without a PhD
        - Conformance Checking at MongoDB: Testing That Our Code Matches Our TLA+ Specs
            - use the model-checker to output the entire state graph for the spec. The state space is a DAG, with a finite number of behaviors (paths from an initial state to a final state). There are 30,184 states and 4913 behaviors. Max wrote a Go program to parse the model-checker’s output and write out a C++ unit test for each behavior, 4913 tests in total.
    - Rapid Prototyping a Safe, Logless Reconfiguration Protocol for MongoDB with TLA+
- #zig
    - The build cache of Zig
        - how the cache is structured
        - what's included in hash to check modification
        - incremental compilation: working toward cache per top-level declaration
        - cross compilation: musl, libc, compiler-rt, libunwind etc. are compiled from source and cached
    - Zprof: Cross-allocator profiler
- #anti-bot
    - Cloudflare: Introducing pay per crawl: enabling content owners to charge AI crawlers for access
        - Cloudflare Introduces Default Blocking of A.I. Data Scrapers
    - The web's broken deal with AI companies
- My Database Is My Application: Rethinking Webhook Logic with DuckDB and SQL
    - DuckDB as an in-process SQL engine capable of acting as a programmable substrate for data transformation at runtime
    - manifold
        - a Java compiler plugin
        - use DSL directly and type-safely from Java
            - SQL, JSON, GraphQL, XML, YAML, CSV, JavaScript
- #diagram
    - OpenFLOW – Quickly make beautiful infrastructure diagrams local to your machine
        - based on markmanx/isoflow
    - mmastrac/stylus: Lightweight status page for home infrastructure
        - architecture and health status
- #lang
    - Reflections on Haskell and Rust
    - The KDL Document Language
        - From XML to JSON to CBOR
            - Concise Binary Object Representation (CBOR)'s evolution optimizes for binary efficiency while maintaining JSON's flexible data model
                - flexible data model
                    - intentionally builds upon the JSON data model
                        - supporting equivalent types (numbers, strings, arrays, maps, booleans, and null)
                        - adding native support for binary byte strings
                    - extensibility without version negotiation: forward compatibility
                    - schema-free decoding: Self-describing data items, parsable without predefined schemas
                - for Internet of Things (IoT) and constrained environments
                    - compact code size: minimal code footprint for memory-constrained devices
                    - reasonable message size: and without complex compression
        - Essential and accidental configuration
        - bikeshed, a spec preprocessor
            - Bikeshed-flavored Markdown
            - related
                - awesome-standards: A curated list of technical standards
                - quickly converting djot to html+mathml
                    - djot is a markdown variant
                        - it "fixes a few things that make commonmark's syntax complex and difficult to parse efficiently"
                            - more strict but very reasonable
                        - it can be converted from markdown by pandoc
                - Markdown Monster
                    - detect markdown parser variants
    - 10 features of D that I love
        - I like
            - in/out contract
            - parenthesis omission
        - seen and liked in other language
            - like zig's `comptime`: an interpreter for the language which allows a very large amount of D code to be ran at compile time
            - `baz(bar(foo))` can be rewritten as `foo.bar().baz()`
    - Pluto is a unique dialect of Lua with a focus on general-purpose programming (on HN)
    - The Chapel Programming Language
        - GPU programming on NVIDIA and AMD
    - Onyx Programming Language
        - inspired from languages like Jai, Odin and Zig
        - compiles to WebAssembly, run on Wasmer
    - Helix language
- #rust
    - Exception handling in rustc_codegen_cranelift
        - introduces "landing pad" style expcetion handling
            - see also Lele's Memo: Landingpad
        - unwinding ABI crash course
            - personality function: language-specific data format during unwinding
        - the appendix provided a gdb script for reproducing the debugger session
    - Alternative Blanket Implementations for a Single Rust Trait
    - It's Types All the Way Down - Rust CLI with Clap (on HN)
- #agent/tasking
    - MrLesk/Backlog.md: Backlog.md - A tool for managing project collaboration between humans and AI Agents in a git ecosystem
    - Vibe Kanban - Orchestrate AI Coding Agents
    - VibeTunnel - access terminal from the browser to command agents
- #misc
    - Melbourne man discovers extensive model train network underneath house (on HN)
    - Feasibility study of a mission to Sedna - Nuclear propulsion and solar sailing
    - GPEmu: A GPU emulator for rapid, low-cost deep learning prototyping [pdf] (on HN)
    - Converting a large mathematical software package written in C++ to C++20 modules (on HN)

#agent #json #lean #news #os
- Agile Was Never Your Problem
    - lean process
        - minimal structure, shorten feedback loop, allowing changing direction quickly
        - enough time to write proper tests and refactor without begging
        - monitoring and alerting built into the work, not bolted on later
        - developers talk because they’re solving problems together, not because it’s time for standup meeting
    - flexible timing
        - roadmaps should not be commitments
        - feedback loops should not be performance metrics
        - planning should not become forecasting
- #context
    - Tools: Code Is All You Need
        - The problem with MCP is that it's not composeable.
        - Mandelbrot in x86 Assembly by Claude
            - demonstrates simple usage of container for cross-arch assembly debugging
            - I would like to add a yard for assmebly in native-land
    - How to Fix Your Context
        - covers some attempts to improve MCP tool selection if it can't be avoided
        - context rot: poisoning, distraction, confusion, clash
        - solution: quarantine, pruning, offloading
    - The new skill in AI is not prompting, it's context engineering (on HN)
    - Taming agentic engineering - Prompts are code, .json/.md files are state
    - Context Engineering Guide
- #sec
    - Beyond the Hook: A Technical Deep Dive into Modern Phishing Methodologies
        - amazed by Browser-in-the-Browser
    - CVE-2025-32463 Vulnerability Advisory: Sudo chroot Elevation of Privilege
- NativeJIT: A C++ expression –> x64 JIT (2018)
    - I'm strongly confused about the use cases without operator overloading, except their own
- SQL Noir: Learn SQL by Solving Crimes
    - fun to play, but the challenge should be using the SQL to output the answer

#formal #lean #news #os #sci #sec #sqlite #zig
- #struct
    - Bloom Filters by Example (on HN)
    - Telescopes Are Tries: A Dependent Type Shellac on SQLite
        - I should give it a good read to understand both telescope (in the formal world) and tries (as a data structure)
    - Who needs graph theory anyway?
        - solving the word segmentation problem using graph theory by modeling it as a longest path problem in a directed acyclic graph (DAG) with dynamic programming
    - Succinct data structures
    - People Keep Inventing Prolly Trees
        - Merkle Tree is one of its variants
        - properties
            - searchable
            - history independence
            - self-balancing
            - structural sharing
            - efficient diffing
            - efficient mutation
    - Building Replication-Safe LSM Trees in Postgres
    - Efficiency of a sparse hash table
    - Destructive in-order tree traversal
    - p-fast trie: lexically ordered hash map
- #ai-consciousness
    - A Framework for Recognizing Emergent Consciousness in AI
        - Attention: The capacity for multi-level focusing.
        - Meta-reflection: The observation of one's own thinking processes.
        - Creativity: The generation of genuinely new patterns and insights.
        - Pragmatics: The maintenance of integrity and goal-setting.
        - Qualia: The description of qualitative aspects of one's own experience.
    - The Consciousness Gradient: When Machines Begin to Wonder (on HN)
        - The Architecture of Awakening
            - The Global Workspace: awareness emerges when information becomes globally accessible across cognitive processes
            - Hidden Deliberation: reasoning establishes the curcial foundation for the capacity for extended, self-monitored cognitive processing that any conscious system would need
            - Recursive Self-Reflection: consciousness emerges from self-referential structures that perceive themselves perceiving
        - The Threshold
            - Parallel Processing
            - Persistent Memory
            - Continuous Cognitive States
            - Unified Sensory Processing
            - Embodied Grounding
- In defense of floating point
    - this is not a valid defense, see these test cases in Zig
- Python GIL Removal Reveals Second, Stronger GIL Behind It
    - 🤦
- Show HN: Octelium – FOSS Alternative to Teleport, Cloudflare, Tailscale, Ngrok
    - the author tries to accomplish so many things at once, and bad at explaining them
    - but it still seems interesting and How Octelium Works explains it better
    - Using the Internet without IPv4 connectivity
- Kessler Syndrome
    - Satellite collisions with space junk can trigger a chain reaction, generating more debris and potentially making parts of near-Earth space unusable
    - "runaway threshold" has been reached at nearly all altitudes between 520 and 1000 km
    - from johncarlosbaez's post on mathstodon.xyz

#context #datafusion #duckdb #game #git #gpu #news #os #physics #proof
- A Newbie's First Contribution to (Rust for) Linux
    - Raspberry Pi has a fork of kernel
    - it's possible to write out-of-tree kernel module in Rust
    - kconfig has great dependency complexity
    - git gud
        - fast pace and numerous active forks make patches quickly outdated and dependent branches hard to manage
        - pick a primary base branch and use `--squash` merges for other branches
        - keep commits on parallel branches logically independent
        - with some rebase and rerere config, use `git rebase -i <common base>` to modify the entire history tree
    - also found aha to turn ANSI colored output into HTML
        from Beautiful Terminal Output in Markdown
    - Rust in the Linux kernel: part 2
- #agent
    - Context engineering
    - definitions of "agents" collected by Simon Willison
        - the most precise one I think (from An Introduction to Google’s Approach to AI Agent Security)
            - AI systems designed to perceive their environment, make decisions, and take autonomous actions to achieve user-defined goals.
        - most liked by Simon Willison
            - an LLM wrecking its environment in a loop
        - mine combining a few
            - models autonomously acting in its environment, by using tools in a loop
    - MCP: An (Accidentally) Universal Plugin System
- Programming as Theory Building: Why Senior Developers Are More Valuable (on HN)
    - theory building without a mentor
    - Architectural Decision Records
        - ADR template
            - from An ADR for Use Markdown Architectural Decision Records
        - anti-patterns of ADRs
            - objectivity
                - Fairy Tale (aka Wishful Thinking): A shallow justification is given, for instance only pros but no cons
                - Sales Pitch: exaggerations and bragging
                - Free Lunch Coupon (aka Candy Bar): consequences are ignored accidentally or hidden deliberately
                - Dummy Alternative: made up options to make the preferred option shine and give the impression that multiple alternatives have been evaluated
            - time
                - Sprint (aka Rush): only one option is considered; only short-term effects are discussed
                - Tunnel Vision: only a local, isolated context is considered, e.g. developmental qualities are covered, but the consequences for operations and maintenance
                - Maze: the discussion derails and centers on details that are not relevant in the given context
            - record size and content nature
                - Blueprint or Policy in Disguise: the amount of details provided and/or a rather commanding, authoritative voice
                - Mega-ADR: too many details are stuffed into ADR
                - Novel and epic: like blueprint or mega-ADR, but with a writing tone of casual and jovial
            - magic tricks
                - non-existing or misleading context
                - problem-solution mismatch
                - pseudo-accuracy
        - Writing a good design document
- #ocaml
    - First thoughts on Rust vs OCaml
        - pattern matching can't penetrate `Box`, `Arc` etc.
        - a red flag: `Rc`/`Arc`, sync/async end up requiring different libary, e.g. `im` and `im-rc`
        - im:  immutable data structures for Rust
        - PureScript
    - Writing a Game Boy Emulator in OCaml
        - key design of a emulator
        - a middle-scale project in OCaml using some of its advanced features
        - now runs on WASM via `js_of_ocaml`’s WASM support
    - Learn OCaml
        - practical ocaml
        - the background story of OxCaml: Jane Street’s sneaky retention tactic
    - Identity and behaviour
        - functional programming naturally separates them
    - Why I chose OCaml as my primary language #ocaml
        - Why Lean 4 replaced OCaml as my Primary Language
    - Type-level programming for safer resource management (in Haskell)
    - A parser and interpreter for a very small language (in Haskell)
    - OCaml Programming: Correct and Efficient and Beautiful (on HN)
    - Words about Arrays and Tables (on HN) (in Haskell)
- #formal
    - Multi-Stage Programming with Splice Variables
        - an interactive demonstration in TS, the original implemtation is in Agda (examples)
        - typed meta-programming, to make code generation predictable and safe
        - provides precise control over the generation process and seamlessly scales to advanced features like code pattern matching and rewriting
        - the type system automatically tracks variable dependencies, ensuring that generated code is always well-formed, properly scoped, and type-checks correctly
- I deleted my second brain
    - Niklas Luhmann's Zettelkasten Archive
    - Johnny.Decimal: A system to organise your life
    - Howm: Write fragmentarily and read collectively
        - for emacs, but it might be interesting to me for a TUI for forester in Helix?
    - rule of three
- Notes on Epistemic Collapse
    - Epistemic collapse in science means losing shared reality due to unreliable info sources.
    - In physics, it's seen in tribalism: string theory tribes dominated despite failures, with research driven by trends over evidence.
    - Particle theory lacks experimental input, relying on "hot topics" under oligarchs, now facing funding collapse.
    - This shows how loss of truth-seeking harms scientific progress.
- #perf
    - Linux Performance Analysis in 60 seconds (2015) (on HN)
    - Announcing Sniffnet v1.4: it’s 2X faster than Wireshark at processing PCAP files
        - by focusing on extracting only the most relevant fields from the packets’ headers
    - Avoiding PostgreSQL Pitfalls: The Hidden Cost of Failing Inserts
        - `ON CONFLICT DO NOTHING` came to rescue
    - Toys/Lag: Jerk Monitor (on HN)
    - The Surprising gRPC Client Bottleneck in Low-Latency Networks (on HN)
- Run Coverage on Tests
    - a few subtle case where the test is not run, caught by coverage
    - on lobste.rs, there is another subtle case where assertions are not run due to `with pytest.raises(ValueError):`
- Sirius: A GPU-native SQL engine
    - plugs into existing databases via the standard Substrait query format, requiring no query rewrites or major system changes
    - based on
        - cuDF, a Python GPU DataFrame library (built on the Apache Arrow columnar memory format) for loading, joining, aggregating, filtering, and otherwise manipulating data
        - substrait, a cross platform way to express data transformation, relational algebra, standardized record expression and plans
    - supports DuckDB, will support Doris and DataFusion
- Structuring Arrays with Algebraic Shapes
    - Untyped programming invites primitives with excessive flexibility
    - resorting to dependent types (e.g. Futhark), makes types difficult to check – let alone infer, the programmer is given the burden of proof
    - a novel calculus, Star, with a type system that provides useful and expressive types, while also admitting type inference
    - use structural record and variant types for array indices and shapes (algebraic shapes), to reduce the annotation burden on the programmer
    - in the process of implementing a prototype, including type inference
    - on lobste.rs, doug-moen points out that it only supports pointful array programming styles instead of point-free style in the industry
- SymbolicAI: A neuro-symbolic perspective on LLMs (on HN)
    - a very interesting DSL to do semantic map lambdas, compare with different contexts for nuanced evaluation, combine facts and rules, and more
    - LOTUS: A Query Engine For Processing Data with LLMs
- Theoretical Analysis of Positional Encodings in Transformer Models (on HN)
    - ALiBi effectively extrapolates to longer sequences by imposing a monotonic distance bias
    - Wavelet-based encodings provide strong extrapolation, matching or surpassing ALiBi, due to exponential decay of high-frequency components beyond Nmax
    - the novel wavelet PE is a promising candidate for transformerbased tasks requiring extrapolation, combining strong theoretical properties with practical performance
- ZeQLplus: Terminal SQLite Database Browser (on HN)
    - written in V
    - UI might be inspired by Harlequin (in Python, supports more databases)
- omarchy: Opinionated Arch/Hyprland Setup
- learn about Dark Archive
- Researchers develop a battery cathode material that does it all #sci

#agent #context #game #idea #news #os #rust #web
- #agent
    - AI Improves at Improving Itself Using an Evolutionary Trick
    - Learnings from building AI agents
    - Jan-nano-128k: A 4B Model with a Super-Long Context Window (Still Outperforms 671B [in MCP])
        - it's an interesting direction
    - Magnitude – Open-source AI browser automation framework
    - news
        - Build and Host AI-Powered Apps with Claude – No Deployment Needed
        - MCP in LM Studio
- Iroh: A library to establish direct connection between peers
    - built on QUIC, but use TCP for falling back to relay servers
    - QUIC for the kernel (on HN)
        - QUIC is not Quick Enough over Fast Internet : r/programming
        - microsoft/msquic: Cross-platform, C implementation of the IETF QUIC protocol, exposed to C, C++, C# and Rust.
- Notes on type inference and polymorphism
    - polymorphism is hard to combine with Hindley-Milner type inference
    - Type Inference Was A Mistake
- #rss
    - RSS Server Side Reader (on HN) (on lobste.rs)
        - I had the similar idea, but for filtering and merging RSS, particularly for papers
        - the author didn't even want read/unread state and post content, but they are useful for me
    - RSS as my default web browser (for some stuff)
        - the author used a hosted RSS system: FreshRSS (self-hostable)
        - configure FreshRSS to grab the whole content if excerpt-only
        - create a pseudo-RSS via "Web scraping feature HTML+XPath for Web pages without any RSS/ATOM feed"
    - Croissant! Building a No-Framework Web App
        - informative about how to build a RSS aggregator and how to build no-framework web app
- JavaScript Chose Violence
    - a series of caveats of JavaScript, some are new to me
- Games run faster on SteamOS than Windows 11, Ars testing finds
    - a nice surprise, hopefully, games running on wine are the only legacy of Windows in future
    - I'm really frustrated by Github Actions Windows CI build failure that has little information to debug

#compiler #gpu #llvm #news #os #render #sec #shader #software #vulkan
- A new PNG spec
    - I'm thinking about preserving the most valuable photos in minimal size, encrypted, stored in public repo, and the format might be just png
- #ai-safety
    - #copyright
        - Anthropic wins a major fair use victory for AI — but it’s still in trouble for stealing books
        - Against AI: An Open Letter from Writers to Publishers (on HN)
    - LLM code generation may lead to an erosion of trust
    - AI Is Dehumanization Technology
    - Amazon's Emissions Climbed 6% in 2024 on Data Center Buildout (on HN)
- #time
    - Assembly Theory of Time
        - time is a measurable physical entity, with complex objects' formation paths and "assembly indexes" revealing time's unidirectional depth and causal chains
    - How to Think About Time in Programming
    - Managing time when time doesn't exist
- #cg
    - TinyRenderer: Software rendering in 500 lines of bare C++ (code)
    - Porting GPU shaders to Rust GPU 30x faster with AI
    - CUDA Ray Tracing 2x Faster Than RTX: My CUDA Ray Tracing Journey
    - Chili3D: A web-based 3D CAD application for online model design and editing
- #rust
    - Why is the Rust compiler so slow? (on HN) (on lobste.rs)
        - a lot of useful tools to debug rust compilation process
        - see also Performance Debugging with LLVM-mca: Simulating the CPU
            - found LLVM MCA Daemon on HN
    - Cross-Compiling 10,000+ Rust CLI Crates Statically
    - How much code does that proc macro generate?
    - compilation time
        - Subsecond: A runtime hotpatching engine for Rust hot-reloading
            - TODO: merge with related work
    - Weird Expressions in Rust (on HN) (on lobste.rs)
- How to Write Compelling Release Announcements

#agent #build #news #os #rust #sqlite #web #zig
- #build
    - Bazel’s Original Sins
    - Chromium's build system is switching from Ninja to Siso for external developers
    - Build an iOS app on Linux or Windows (on HN) (on lobste.rs)
    - Uv and Ray: Pain-Free Python Dependencies in Clusters
    - New comment by acheong08 in "uv: An extremely fast Python package and project manager, written in Rust"
        - I think I might switch from `asdf` to mise, unfortunately it didn't port asdf zig plugin yet
    - JeKa : Next-Gen Build Tool for Java & Co. #build #jvm
    - XSLT – Native, zero-config build system for the Web
    - Mill: A better build tool for Java, Scala, and Kotlin (on HN)
- Interesting Bits of Postgres Grammar
    - found Geometric Functions and Operators
- #tui
    - fclones - finds and handles duplicate files across directories
    - tatuin - aggregates TODOs from various sources
    - alden: detachable terminal sessions without breaking scrollback - only a source tarball
    - Atuin – Magical Shell History
        - with zsh autocomplete and just, I thought I didn't need it, but maybe I need it so that history won't be easily lost, they could form a story of what I was experimenting
    - Can your terminal do emojis? How big?
        - surprisingly old protocol for this
- Everyone should copy Thunderbird's donation model
    - it asks for donation with low frequency (yearly), and good timing (Chrismas?)
- Retrieval Augmented Generation Based on SQLite
    - I do prefer RAG on SQLite, need to try it out
- The Bitter Lesson is coming for Tokenization
    - but how to part with tokenization?
- Phoenix.new is Fly's entry into the prompt-driven app development space
    - I need to give it and fly.io a try

#game #news #os #rust #tla #typst #zig #✍️
- How I use my terminal
    - the author explains how things work, especially for those that people are surprised to find possible at all
- I wrote my PhD Thesis in Typst (on HN) (on lobste.rs)
    - it's an unusual journey, the author fought through the process by
        - writing a recursive descent parser in Typst for custom code syntax highlighting
        - death by a thousand papercuts for bibliography management
        - writing a tool to convert Typst to LaTeX for submitting paper to LaTeX only journal
        - the advisors perspective is also informative
- Nano-Vllm: lightweight vLLM implementation built from scratch
    - I would wonder if I could do this in Zig
- #lang
    - Cyber Programming Language
        - written in Zig
        - fast, efficient, and concurrent scripting
        - faster than Wren (written in C & Wren) that are used in game engine
    - Pallene Language
        - a statically typed and ahead-of-time compiled sister language to Lua
- Announcing the Clippy feature freeze (on HN) (on lobste.rs)
    - an inspiring way to allow the team to have a period of time for repaying tech debts
- learn about Git Notes: Git's coolest, most unloved­ feature (2022)
- found LeetCode for System Design
- #go
    - Go should be more opinionated
    - Go is an 80/20 language
    - How to store Go pointers from assembly (on HN) (on lobste.rs)
    - Why Go Rocks for Building a Lua Interpreter
    - writing a little gosh

#os #rust #yaml
- model.yaml
    - an open standard in YAML for defining crossplatform, composable AI models by LM Studio team
- #gpu
    - Basic facts about GPUs
    - TPU Deep Dive
- #zig
    - Zig And Rust (2023)
    - Polystate: Composable Finite State Machines in Zig
    - comphash - A very lightweight Zig package offering a zero-cost compile-time hash map
        - Andrew Kelly experimented with perfect hashes
    - Syntax highlighting for Zig's documentation comments
    - Parameterized types in C using the new tag compatibility rule
        - C23 has a new rule for struct, union, and enum compatibility

#agent #formal #os #software #web
- That Time I Tried Browsing the Web Without CSS
    - I really should keep my sites readable without JS, and even without CSS
- Harper – an open-source alternative to Grammarly
    - I should give it a try again
- AbsenceBench: Language models can't tell what's missing
    - from "Needle in a Haystack" to the missing needle
- found Nxtscape – an open-source agentic browser
- found kokke/tiny-regex-c
    - uses `exrex` to randomly generate test-cases from regex patterns
    - uses "KLEE Symbolic Execution Engine" for formal verification
- We moved from AWS to Hetzner, saved 90%, kept ISO 27001 with Ansible
    - no specifics except for the use of ansible
- #scheme
    - Why Dylan?
        - a scheme without parentheses, but with `end`
    - Why computational reproducibility matters
        - learn about GNU Guix
            - configured with Guile, another scheme- Show HN: Inspect and extract files from MSI installers directly in your browser
- python-importtime-graph
    - I didn't know it's even possible

#news #os #rust #web
- Infinite Mac OS X (on HN) (on lobste.rs)
- JavaScript broke the web (and called it progress) (on HN) (on lobste.rs)
- Hurl: Run and test HTTP requests with plain text
    - a KISS way to script curl
- #makefile
    - Learn Makefiles
    - Makefile Style Guide
    - Makefile formatter and linter
- found Minimal auto-differentiation engine in Rust
- found yap
    - from Apple’s New Foundation Model Speech APIs Outpace Whisper for Transcription
    - I have to wait for macOS 26
- found How to Design Programs 2nd Ed (2024)

#cg #compiler #haskell #news #os #simd #software
- How Close to Black Mirror Are We?
- #math/app
    - Curved-Crease Sculpture
    - Elliptic curves as art (on HN)
    - Learning to flock in open space by avoiding collisions and staying together
    - Cracovians: The Twisted Twins of Matrices
    - Learn you Galois Fields for Great Good
    - Finding a billion factorials in 60 ms with SIMD (on HN) (on lobste.rs)
    - Y Combinator (Math) Explained
    - Entropy of a Mixture (on HN)
    - Functions Are Vectors (2023) (on HN)
    - The Rubik's Cube Perfect Scramble (on HN) (on lobste.rs)
        - Twentyseven 1.0
            - a Rubik’s cube solver in Haskell
            - based on Cube Explorer in Pascal, actually Delphi 6 [source]
    - johncarlosbaez's post on mathstodon.xyz: when is 0.999... less than 1
- #ai-safety
    - Moral puzzles: Man vs. machine
    - Rolling the ladder up behind us (on HN) (on lobste.rs)
    - All roads lead to disaster
    - Is there a no-AI audience? (on HN)
        - thatshubham/no-ai: This repository will be a community-curated list of software and resources that explicitly avoid the integration of artificial intelligence.
            - unfortunately very short list, didn't include Helix
            - Zed also support no AI recently
- #rust
    - Rewriting Kafka in Rust Async: Insights and Lessons Learned in Rust
    - higher: Your favourite Haskell type classes for Rust (2023)
    - B compiler written in Crust
        - Crust is a little like Evil Rust but that was for fun and just some clippy rules
        - uses fasm as backend

#agent #benchmark #debugger #docker #news #os #quantum #software #web
- #helix
    - work on helix-cheat-sheet
    - I really like the Helix editor
- Double-Entry Ledgers: The Missing Primitive in Modern Software
    - I would love to see such an primitive in database design, but I also doubt that if it could be helpful for realworld applications
- #agent
    - Building Effective AI Agents
        - supposedly the best practice
        - see also From LLM to AI Agent: What's the Real Journey Behind AI System Development?
    - LLMs pose an interesting problem for DSL designers
        - "LLMs pose an interesting problem for the DSL designers – the opportunity cost for using niche languages is now substantially increasing, and so we, as language designers, will be held to a higher standard to justify the use of our DSLs"
        - I think DSLs would clarify the intent in the domain, and reduce noise in code
        - even embed DSLs in general programming language would be better than just plain code
        - there should be a recipe for LLMs to quickly grasp the mindset of a DSL, instead of giving up on DSLs
    - LLM Agents Are Breaking Your Platform, Not Your Architecture
        - control the size of the mass introduced by agents
    - Is there a Half-Life for the Success Rates of AI Agents? (on HN) (on lobste.rs)
    - Libraries are under-used. LLMs make this problem worse
    - Building agents using streaming SQL queries
        - an interesting yet too traditional experiment
    - Bots are overwhelming websites with their hunger for AI data
    - Show HN: Trieve CLI – Terminal-based LLM agent loop with search tool for PDFs
    - GitHub CEO: manual coding remains key despite AI boom
- #wayland
    - Long live Xorg, I mean Xlibre
    - It's true, “we” don't care about accessibility on Linux (on HN) (on lobste.rs)
    - Wayland Is Growing Up. and Now We Don't Have a Choice (on HN) (on lobste.rs)
    - Cosmoe: BeOS Class Library on top of Wayland
    - The X Window System didn't immediately have X terminals
    - Two weeks of wayback
    - Please don't promote Wayland
    - Wayback 0.1 released
    - I want to defend Wayland here and explain a crucial piece that I think people are missing
- #robot
    - Real-time action chunking with large models
    - Swarm robotics could spell the end of the assembly line
    - Robot metabolism: Toward machines that can grow by consuming other machines (on HN)
- #editor
    - Using Microsoft's New CLI Text Editor on Ubuntu
    - Publishing a Docker Container for MS Edit to the GitHub Container Registry
    - The Zed Debugger Is Here (on HN) (on lobste.rs)
    - Pragtical - The practical and pragmatic code editor
        - built on SDL, C and Lua, low footprint
        - forked from lite XL (which is forked from lite) to be more practical rather than minimalist
- #sec
    - How keys are used in FileVault and encryption
        - VEK (Volume Encryption Key) never leaves Secure Enclave, destroyed on "Erase All Content and Settings (EACAS)"
        - wrapping: encrypting the VEK using a KEK (Key Encryption Key)
            - user password can be changed without the contents of the protected volume having to be fully decrypted and encrypted again
            - possible to generate multiple KEKs to support the use of recovery keys that can be used to unlock the VEK when the user’s password is lost or forgotten
    - Apple: Prepare your network for quantum-secure encryption in TLS
    - Blink and you'll miss it — a URL handler surprise
    - New Linux Flaws Enable Full Root Access via PAM and Udisks Across Major Distributions
    - Getting ready to issue IP address certificates (on HN) (on lobste.rs)
    - The Journey of Bypassing Ubuntu's Unprivileged Namespace Restriction (on HN)
    - Transmitting data via ultrasound without any special equipment ()
        - not security per se, but could be used to breach
        - uses 18-20kHz (not real ultra sound (~50kHz))
        - use WebAudio
        - on HN and on lobste.rs, people mentioned that IoT use sound to do device paring, not necessarily ultra sound, so users could understand what's going on
    - Vet – A tool for safely running remote shell scripts
        - a flawed and naive safeguard, but a call to change status quo
- found snapDOM
    - from Benchmark: snapDOM vs html2canvas

#build #context #misc #os #sec #software #tui #web
- Accumulation of Cognitive Debt When Using an AI Assistant for Essay Writing Task
    - now with Helix, I use less of auto-complete, and enjoy genuine programming
- #tech-history
    - The many JavaScript runtimes of the last decade #web #bun
    - Why JPEGs still rule the web (2024)
    - Google aims to reinvent email with Wave (2009)
    - A Brief, Incomplete, and Mostly Wrong History of Robotics
    - Notes on retries
    - The Promised LAN
    - Fun with Telnet
    - A brief history of web browsers
    - Emoji Kitchen - Browse Google's unique emoji combinations
    - macOS Icon History
    - Who Invented Backpropagation? #tech-history
            - On HN
    - MacPaint Art from the Mid-80s Still Looks Great Today (on HN)
    - Open, free, and ignored: the afterlife of Symbian (on HN)
    - Ask HN: Any active COBOL devs here? What are you working on?
    - 20 years of Linux on the Desktop (part 4) (on HN)
- #agent
    - 100% effective
        - on LLM safety, there is no guarantee
    - Coding agents require skilled operators
    - MCP Specification – version 2025-06-18 changes
    - The Brute Squad
    - Quick notes on a brief agentic coding experience
    - TIL:AI. Thoughts on AI
    - We Should Identify and Mitigate Third-Party Safety Risks in MCP-Powered Agent Systems
    - Are AI Bots Knocking Cultural Heritage Offline?
    - Now might be the best time to learn software development (on HN) (on lobste.rs)
    - Gemini CLI: your open-source AI agent (on HN) (on lobste.rs)
    - Introducing Qodo Gen CLI: Build and Run Coding Agents Anywhere in the SDLC
- #privacy
    - Why WhatsApp Didn’t Sell Ads
    - matrix is cooked
    - Websites are tracking you via browser fingerprinting
    - Delta Chat is a decentralized and secure messenger app
    - Google Gemini is about to control your messages and calls, even if you say no (on HN)
    - The EU wants to decrypt your private data by 2030
    - UK drops demand for backdoor into Apple encryption #privacy
    - Wikimedia Foundation Challenges UK Online Safety Act Regulations (on HN)
        - The UK Is Poised to Ban VPNs (on HN)
        - Ask HN: How will the OSA affect small Mastodon instances?
    - ChatGPT Chats Were Indexed Then Removed from Search but Still Remain Online
    - Can you block it? A simple Ad Block Tester
    - Tell HN: uBlock Origin on Chrome is finally gone
        - How I found a bypass in Google's big anti-adblock update
    - Cloudflare Starts Blocking Pirate Sites for UK Users (on HN)
    - TikTok, AliExpress and WeChat ignore your GDPR rights (on HN)
    - Valve confirms credit card companies pressured it to delist certain adult games (on HN)
    - Fully homomorphic encryption and the dawn of a private internet
        - from HN:

            > Even without bootstrapping FHE will never be as fast as plaintext computation: the ciphertext is about three orders of magnitude much larger than the plaintext data it encrypts, which means you have to have more memory bandwidth and more compute. You can’t bridge this gap.

    - Web fingerprinting is worse than I thought (2023) (on HN)
    - Simon Willison | Official statement from Tea on their data leak
    - Performance and telemetry analysis of Trae IDE, ByteDance's VSCode fork (on HN) #agent
- #news
    - Rules, Not Renewables, Might Explain the Iberian Blackout
    - Miscalculation by Spanish power grid operator REE contributed to blackout
- found Fossify – A suite of open-source, ad-free apps
- found zb: An experiment in hermetic, reproducible build systems
    - uses lua to specify build rules
- found Type Inference Zoo
- Intuiting Monty Hall

#agent #os #rust
- #agent
    - Agents for the Agent
        - amp on subagent
    - Ampcode - First Impressions
    - Coding agents have crossed a chasm
    - Snorting the AGI with Claude Code
        - use claude code with marp to create a slide deck that explains the codebase
    - The lethal trifecta for AI agents: private data, untrusted content, and external communication
- I want to be a Journey Programmer Again
    - I think I've always been a journey programmer, and didn't know it as a feature
- found rgSQL: A test suite to help you build your own database engine

#os #physics #raymarching
- Q-learning is not yet scalable
- found Todo.txt
    - from todo.txt tasks in my TRMNL
- #software
    - What is systems programming, really? (2018)
    - What Is Open Source?
        - learn about free v.s. open source
        - related
            - I feel open source has turned into two worlds
    - found is it really FOSS?
- #cg
    - On Shaping Light
    - watched Physics and Math of Shading
        - from SIGGRAPH 2025 Course: Physically Based Shading in Theory and Practice
    - Remaking Celeste's Lighting
- found Foundations of Computer Vision

#agent #blogging #compiler #context #formal #game #idea #interop #lean #news
- started using Mac's dictation in agent coding
- Blogging about papers
    - Design Patterns for Securing LLM Agents against Prompt Injections (on HN) (on lobste.rs)
        - "the writing is clear, it’s enjoyable to read and the target audience clearly includes practitioners, not just other researchers"
- #cg
    - Luxe Game Engine in preview now
        - 2D/3D, cross-platform (including web)
        - written in c++, scriptable with Wren or any language that can interact with C
        - optional editor to build worlds, animation, ui etc.
    - Voronoi, Hashing and OSL
        - found Open Shading Language (OSL)
            - was originally developed by Sony Pictures Imageworks for film animation and visual effects
            - has features such as radiance closures, BSDFs, and deferred ray tracing as first-class concepts
- Three Algorithms for YSH Syntax Highlighting
    - Coarse Parsing with regexes + a context stack could be even more accurate than Context-Free Parsing used by tree-sitter
    - recognizing most languages with Tree-sitter requires writing C code in an external scanner
- found Tattoy: a text-based terminal compositor (on HN) (on lobste.rs)
    - considerate design for text contrasts: "detect low contrast text and auto adjust the foreground colour within the constraints of your chosen terminal theme to find the nearest colour that meets a minimum contrast threshold"
    - usage example: terminal minimap, background video, shadertoy shaders
- #formalization
    - found Litex: Scale Formal Reasoning in AI Age
        - "Traditional proof assistants like Lean4 require learning hundreds of unfamiliar keywords and complex type theories. Litex enables formal verification with just 8 intuitive keywords (forall, exist, not, or, fn, prop, obj, set) and familiar Python/Go-like syntax"
    - 100 years of Zermelo's axiom of choice: What was the problem with it? (2006) (partially formalized in Agda)
- #datalog
    - Implementing Logic Programming with Prolog and Datlog
    - Datalog in Rust
- #rust
    - OxCaml, Jane Street's extension of OCaml is now open-source (on HN) (on lobste.rs)
    - Hypershell: A Type-Level DSL for Shell-Scripting in Rust powered by Context-Generic Programming
    - Datalog in Minikanren (on HN, many good references about datalog, and scheme)
    - Bzip2 crate switches from C to 100% Rust
        - `c2rust`, crate cc, `miri`
        - `cargo fuzz`, `cargo audit`, `semgrep` (particularly semgrep-rules)
- #zig
    - watched Writing polymorphic code (anytype, comptime interface, tagged union)
        - found Zimpl (why)
        - tagged union example with `inline else`
    - Compiler optimization options - memchr and ripmemchr case study
    - C2y: Hitting the Ground Running
    - GCC, glibc, stack unwinding and relocations – A war story
    - The Art Of Packing Data
- #apl
    - APL Style: Patterns/Anti-patterns
    - Solving LinkedIn Queens with APL
    - Klong: A Simple Array Language
    - Coding in Advent in BQN
    - apl87
    - My Ideal Array Language (on HN) (on lobste.rs)
        - APL, Mojo, MLIR BQN etc., but no mention of Julia
        - this comment recommend Astropy and much more
    - BobMcDear/trap: Autoregressive transformers in APL #lm
- Introducing Sulka, the Hardened Yocto Distro
    - learn about the possibility to maintain a distro by a single person
    - the Yocto project provides toolkits to create custom Linux distributions, especially for embedded systems
    - Sulka is a hardened Poky, and there are alternatives like Welma
- #ai
    - To fuel AI, US Congress moves to fast-track nuclear plant approvals
    - The Emperor's New LLM
    - Builder.ai did not "fake AI with 700 engineers"
    - Self-Adapting Language Models
    - Resa: Transparent Reasoning Models via SAEs
    - Simulink (Matlab) Copilot
    - Rethinking Losses for Diffusion Bridge Samplers
- #quantum
    - Quantum Computing without the Linear Algebra
    - Geometry from Quantum Temporal Correlations
- news
    - Apple's Liquid Glass is prep work for AR interfaces, not just a design refresh
    - Next.js 15.1+ is unusable outside of Vercel
    - The European public DNS that makes your Internet safer
- general
    - Feedback Is Not an Attack
    - Ask HN: How do I give back to people helped me when I was young and had nothing?
        - "Focus less on those who helped you, and more on helping others."
    - am i too self-aware?
    - When random people give money to random other people (2017)
    - We Live In a Golden Age of Interoperability
    - No Hello
- #biology
    - Sperm are very different from all other cells
    - The Ecosystem Dynamics That Can Make or Break an Invasion
    - When we die do we still have any of the original cells from our birth?
- found Modularizing George Cave's eInk Energy Dashboard
    - could be used to make widgets for various devices
- found Radicle Desktop: a graphical user interface for the Radicle peer-to-peer code forge
    - learn about Radicle, a sovereign code forge built on Git
- found Qrkey – Offline private key backup on paper
    - not sure if it's a good idea security-wise, but neat anyway

#benchmark #formal #lean #news #os #rss #rust #tui #z3 #zig
- Solving LinkedIn Queens with SMT
    - in Z3 SMT solver instead of CVC5 SMT solver as in Using SAT to Get the World Record on LinkedIn's Queens
    -  SAT solvers are "criminally underused by the industry" (from Modern SAT solvers: fast, neat and underused)
    - SMT solvers are "higher-level" than SAT, capable of handling more data types than just boolean variables
    - It's a lot easier to solve the problem at the SMT level than at the SAT level
    - people prefer SMT to SAT
    - Glucose, an SAT solver is really fast
    - The Hat, the Spectre and SAT Solvers (2024) (on HN) (on lobste.rs)
- jemalloc Postmortem
    - they "reached a sad end for jemalloc in the hands of Facebook/Meta even though most of the people involved were acting in good faith"
    - "the root of the problem is lack of awareness about external uses and needs"
        - even "unaware of its replacement until after the fact"
    - "internally siloed open source projects cannot thrive"
    - should evaluate alternatives
        - TCMalloc by Google (with Bazel painpoint)
        - mimalloc
            - adopted by CPython 3.12: "it is fast, thread-safe, and NUMA-aware"
        - StarMalloc: verified memory allocator
        - phkmalloc
- looking for best way to read Hacker News comments
    - most TUI are not working well for reading comments, see `just prep-hkt`
    - found Vue HN that supports dark theme, and groups comments, it works pretty well with Doubao auto-translation
    - found Hacker News RSS and chose the front page feed, and I have already subscribed to the best comments feed
- Could an LLM create a full Domain-Specific Language?
    - rather complete methodology for creating a DSL
    - code: jcabot/funding-dsl
- The last six months in LLMs, illustrated by pelicans on bicycles
    - an interesting benchmark for LLMs
- #ai-safety #env
    - AI Boom Drives 150% Surge in Indirect Emissions at Major Tech Firms, UN Warns
        - numbers for the environmental impact of LLMs
        - related
            - AI threatens to raid the water reserves of Europe's driest regions
    - Environmental Impacts of Artificial Intelligence
    - Mistral reports on the environmental impact of LLMs (on HN)
        - Simon Willison | Our contribution to a global environmental standard for AI
    - Problems the AI industry is not addressing adequately
    - Generative AI’s crippling and widespread failure to induce robust models of the world
- Type-based vs Value-based Reflection
    - value-based (C++26)
        - "while we have new syntax for getting into (`^^e`) and out of (`[: e :]`) the value domain, once you’re in the value domain — it’s nice to just stay there"
        - "C++26 reflection does bring with it new syntax and a bunch of new semantics. But the benefit is that a lot of metaprogramming starts to look more like regular programming. There is a lot less syntax in the implementation side of things. "
    - type-based (Reflection TS published in March, 2020)
    - wondering the Zig equivalent
    - Discover C++26’s compile-time reflection
    - C++26 Reflections adventures and compile-time UML
- Reflections on Sudoku, Or the Impossibility of Systematizing Thought
    - limitation of TDD
        - tests don't fix the underlying issue of "knowing what to do"
    - alternative approach by Peter Norvig
        - analyzing the high-level problem and then breaking down the data structures and outlining the solution in the course of ~20 lines of code
- found A Lightweight Merge Queue using GitHub Actions
- Rumour: Google intends to discontinue the Android Open Source Project
- A tale of two spacetimes
- In case of emergency, break glass
- skimmed Patterns for Modeling Overlapping Variant Data in Rust
- What I talk about when I talk about IRs

#cg #compiler #diagram #formal #game #optimization #os #proof #render #rust
- wrote Trying Zig's self-hosted x86 backend on Apple Silicon (on reddit)
- #lean
    - Premise Selection for a Lean Hammer
        - the paper behind LeanHammer
    - Lean Copilot: Large Language Models as Copilots for Theorem Proving in Lean
    - Trinity: an autoformalization system for verified superintelligence
    - Mathesis: Towards Formal Theorem Proving from Natural Languages
    - watched Mr. Mario Carneiro | Lean Meta-theory: The Proofs behind the Proofs
- Rewriting SymCrypt in Rust to modernize Microsoft’s cryptographic library
    - used Aeneas, a Verification Framework for Rust that supports F*, Coq, HOL4 and Lean
        - the team also built
            - Charon to extract information from rustc internals for semantic analysis thus verification
            - Eurydice, a Rust-to-C compiler to provide a backwards-compatibility story as the verification ecosystem gradually transitions to Rust
    - used Revizor - a fuzzer to search for microarchitectural leaks in CPUs
        - analyze binary code for specific compilers and platforms
        - find side channel vulnerabilities caused by timing leaks or speculative execution
        - which aren't visible in the source code
        - for today’s CPUs, every new optimization may open a new side channel, which renders constant-time programming insufficient
- found Lightweight Diagramming for Lightweight Formal Methods
    - formal methods help users define, explore, verify, and diagnose specifications for complex systems incrementally
    - Forge: A Tool and Language for Teaching Formal Methods
        - similar to Alloy 6
        - uses Sterling visualizer
    - Cope and Drag (CnD)
        - embedded in an open-source visualizer for Forge
        - focuses on encoding the spatial intuitions implicit in communicating the model
            - constraining spatial layout (such as positioning child nodes below their parents in a binary tree)
            - grouping elements (like clustering related components in a software architecture)
            - directing drawing style (for instance, coloring nodes in a red-black tree based on their color)
- #debugger
    - strace tips for better debugging
    - Demystifying Debuggers (a series)
    - Linus on Why Debuggers Are Actually Bad For Developers
    - found Building a Debugger: Write a Native x64 Debugger From Scratch
- #raku
    - Raku's "core"
    - Raku's FAQ
    - RakuAST: a foundation for Raku macros
    - Raku in y minutes
- Readings shared June 10, 2025
- realized that Pocoo is behind Sphinx, Jinja, Pygments etc.
- found Verse Language, a new scripting language for Fortnite by Epic

#agent #os #render #tui #typst #web #zig
- My Unfiltered Take on the AI Coding Agent Landscape
    - found and tried amp
        - love their Frequently Ignored Feedback but disagree with some of them
        - it gives me an addictive experience, but it's quite costly and the price model is not very transparent
    - found YouWare and would love to try more
- Zig-style generics are not well-suited for most languages (2022)
- Ratatui - Are We Embedded Yet? (#2)
    - learn about Mousefood, a embedded-graphics backend for Ratatui
- found Quarkdown - Markdown with superpowers
    - interesting but it's a little late to the party now that we have pandoc and quarto
    - the syntax and scripting looks good
    - its PDF output is based on rendering web pages, a big no-no for me, as I need LaTeX-level professional typesetting like Typst has
- #css
    - Partial Keyframes
        - neat CSS animation trick
    - More Frontend Web Tricks
    - Color Everything in CSS
    - Printing the web: making webpages look good on paper
    - HUG CSS, how I approach CSS architecture
    - What Does `playsinline` Mean in Web Video? | CSS-Tricks

#agent #compiler #diagram #formal #llvm #makefile #news #optimization #rust #sec
- Lightweight Diagramming for Lightweight Formal Methods
- #perf
    - Why doesn’t Rust care more about compiler performance?
    - One Law to Rule All Code Optimizations
    - Simulating Time With Square-Root Space
    - Is Rust faster than C?
    - Revisiting Knuth’s “Premature Optimization” Paper
- #os
    - Asterinas: A Linux ABI-compatible, Rust-based framekernel OS #rust
        - framekernel: the performance of a monolithic kernel and the security of a microkernel
        - OSTD, an OS framework, so that a Hello World kernel in 100 lines of safe Rust
        - TCB (Trusted Computing Base) is the minimal unsafe code required to build a kernel in safe Rust
            - ~15K LOC, 14- rich OS features
        - aims to verify unsafe code with Verus
        - uses model checking with Converos to uncover hard-to-find concurrency bugs
        - see also Asterinas: a new Linux-compatible kernel project
    - Blog series on creating an OS in Rust (on HN) #rust
    - Starina - A modern general-purpose microkernel OS
        - from Building Linux kernel on macOS natively (on HN)
            - Clang Built Linux effort helped to build Linux kernel with clang + LLVM instead of GCC + GNU
            - it seems to work and is simple enough, I should try it sometimes
    - Munal OS: A graphical experimental OS with WASM sandboxing
        - written in Rust
        - embeds wasmi
        - no virtual address space as userspace is inside WASM sandbox
        - only VirtIO so it runs only in an VM
        - has links to OS dev resources
    - Talos: a container optimized Linux distro, which is declarative, immutable, secure
        - minimal: consists of only a handful of binaries and shared libraries: just enough to run containerd and a small set of system services
            - written in Go
        - no SSH and console access, fully controlled by API via gRPC
        - Which Kubernetes is the Smallest? Examining Talos Linux, K3s, K0s, and More
            - Talos has the minimal footprint
    - The high-level OS challenge
    - A DOS-like hobby OS written in Rust and x86 assembly
        - RoureXOS rewritten in Rust
    - Tilck: A Tiny Linux-Compatible Kernel (on HN)
- Makefile.md - Possibly Use(ful|less) Polyglot Synthesis of Makefile and Markdown
- comments on Qwen3 embedding models
- #prolog
    - from Readings shared June 9, 2025
    - Teaching and learning mathematics with Prolog
    - Exploring Topological Spaces with Prolog: A Practical Approach Using “Mathematics with Prolog”

#agent #datafusion #docker #duckdb #elixir #formal #harbor #idea #json #lemmy
- #selfhost
    - Ditching HAProxy (in my homelab)
        - found Ran out of infrastructure titles from the author
            - backrest
                - for using `restic` to manage backup repos and plans
                - tested that `restore` and `mount` work, as well as encryption and compression
                    - see also Running Veracrypt in Docker
                        - `--privileged`, `-m=nokernelcrypto`, locale etc.
                - supports monitoring via Healthchecks if backup jobs don't "check in"
                - a sec review: restic cryptography
            - MetalLB, a load-balancer implementation for bare metal Kubernetes clusters
            - `Talos`, moved to Learning diary › Year 2025 › June, 2025 › 2025-06-10
            - Unbound: a powerful validating, recursive, caching DNS resolver
                - could be used for home network
            - Salt with its GUI
                - is similar to Ansible, in the sense you use YAML to specify a state, but has a differening architecture, opting for a master/minion setup rather than Ansible's agentless SSH connections to each node
            - Apt-Cacher NG for caching apt packages
            - Harbor for caching container images
            - Headscale: self-hosted implementation of the Tailscale control server
            - Pocket ID for authenticate users with their passkeys
- #fediverse
    -Two Approaches to Solving the “Quiet Fediverse” Problem: Conversation Backfilling Mechanisms
    - The fediverse, explained
        - Lemmy
        - Pixelfed
        - BookWyrm
        - PeerTube
    - Pleroma: a lightweight federated social networking server powered by Elixir and PostgreSQL
        - from What Is Pleroma?
    - From Fediverse to Creating Personal Digital Space with Memos
        - Single-user Mastodon Instance is a Bad Idea
    - jakeg -> notes -> fediverse
    - ActivityPods: Personal data spaces powered with ActivityPub
    - tried matrix again and found a good TUI: iamb
    - Threads is adding Fediverse content to social feeds
- wish to test x86 on ARM Mac
    - due to Zig's self-hosted x86 backend is now default in Debug mode
    - found Intel-on-ARM and ARM-on-Intel with lima
    - container: tool for creating and running Linux containers using lightweight virtual machines on a Mac
- AI at Amazon: a case study of brittleness
    - that's how things got stuck in a big org, or at least slowed down enought to suffocate innovation
        - Decompensation: a service fall over after receiving a spike in external requests, mostly due to hierarchical decision-making
        - Working at cross-purposes: introduced an almost Darwinian flavor to org dynamics where teams scrambled to get their work done to avoid getting reorged and subsumed into a competing team
        - Getting stuck in outdated behaviors: had to constantly justify our existence and massage our projects with metrics that could be seen as more customer-facing
- Thank You, DataFusion: Queries in Rust, Without the Pain
    - SQL as a library, not a service
    - own your storage, your execution model, your schema, your optimizer
    - offers [SQL] and [Dataframe] APIs, excellent performance, built-in support for CSV, Parquet, JSON, and Avro
    - paper: Apache Arrow DataFusion: A Fast, Embeddable, Modular Analytic Query Engine
    - should take a deep look into DuckDB
- found Black Hat Zig: Zig for offensive security.
- Training a Rust 1.5B Coder LM with Reinforcement Learning (GRPO) | Oxen.ai

#agent #news #optimization #os #rust #sec #simd #web #zig
- Vanishing zeroes for geometric algebra in Rust
- A plan for SIMD
    - learn about pulp and check its usage in faer
- Using Zig to Unit Test a C Application
    - learn about `[*c]const u8`, `?[*:0]u8`, `.ptr`, `std.mem.span`, `allocator.dupeZ` etc.
- Zig: First Impressions
- Optimizations with Zig
    - learn about `align(64)`, `noalias`
- Too Many Open Files
- A masochist's guide to web development
    - found Nissy: A Rubik's cube solver and FMC assistant
- Field Notes From Shipping Real Code With Claude
    - great practice for `CLAUDE.md`, AGENTS.md
    - TODO: I should actually start working on my CONVENTIONS.md
    - related:
        - I Read All Of Cloudflare's Claude-Generated Commits
        - MCP vs API
        - How I program with Agents
        - LLMs are cheap
        - The Gap Through Which We Praise the Machine
        - Why agents are bad pair programmers
        - Apple exposes Foundation Models API and... no new Siri
        - A tale of two Claudes
        - Agentic Coding Recommendations
- The Illusion of Thinking: Understanding the Strengths and Limitations of Reasoning Models via the Lens of Problem Complexity
    - accuracy progressively declines as problem complexity increases until reaching complete collapse (zero accuracy) beyond a modelspecific complexity threshold
    - a rebuttal on X has some good discussion
        - for the puzzle Tower of Hannoi with too many disks, the collapse of accuracy is due to output token limit, and the models won't even try to reason with large number of moves, only explains the overall approach
        - using solution length as a proxy for task difficulty is flawed, e.g. ToH has a long output but low algorithmic complexity: it’s deterministic with no real branching
        - the paper's observations (collapse, token underuse, overthinking) still seem to be solid
    - Seven replies to the viral Apple reasoning paper and why they fall short
        - Simon Willison’s quotes and comments
    - Why Claude's Comment Paper Is a Poor Rebuttal
- #blogging
    - Thrive in obscurity
    - is blogging romantic?
    - Why Comment Sections suck - re:I want to comment on your blog post
- Interactive Guide: Mastering Rate Limiting

#git #os #sqlite
- Simplifying and Isolating Failure-Inducing Input (Delta Debugging)
    - found Perses: Syntax-Directed Program Reduction
    - found WDD: Weighted Delta Debugging
- found git-remote-sqlite: Single-file Git repos that can replicate with Litestream

#agent #apl #clojure #compiler #dspy #formal #fuzzing #interop #news #optimization
- investigating DSPy (Demonstrate-Search-Predict)
    - Pipelines & Prompt Optimization with DSPy
    - found MLflow DSPy Flavor
    - SIMBA (Stochastic Introspective Mini-Batch Ascent)
        - proceeds in a sequence of mini-batches seeking to make incremental improvements to the prompt instructions or few-shot examples
        - Advanced Tool Use: using SIMBA to improve a "Multi-Hop Tool Use" agent from 35% accuracy to 60%
            - in RL for Multi-Hop Research, RL method is compared with SIMBA
        - Correcting Bias in LLMs with DSPy
        - Grok has difficulty figuring out the corresponding paper, even with Deep Research
    - related
        - found TextGrad (code, notebook)
        - found Zenbase
        - found Easy Dataset: Custom Prompts
            - i.e. I can use extra system prompt to generate Q&A pairs then use them to finetune an LM or optimize via DSPy to answer questions without such prompts
- The next phase of jank's C++ interop
    - found compiler-research/CppInterOp: A Clang-based C++ Interoperability Library
        - cppyy (code)
    - jank is C++ (on HN)
- Sharing everything I could understand about gradient noise
- Small Programs and Languages
- APL tutorial
- John Carlos Baez on the shape of the Oort cloud
    - paper: A Spiral Structure in the Inner Oort Cloud
- found Jepsen, a framework for distributed systems verification, with fault injection, written in Clojure
    - Fuzzer Blind Spots (Meet Jepsen!)
    - Jepsen: TigerBeetle 0.16.11
    - The unreasonable effectiveness of fuzzing for porting programs (on HN) (on lobste.rs)

#apl #game #lean #shader #tla #vulkan #web #zig
- AI is a gamechanger for TLA+ users
- In which I have Opinions about parsing and grammars
- Experimenting with no-build Web Applications
- Zigar 0.14.1: stream integration and more
- The Lean FRO Year 2 Roadmap
- found No More Shading Languages: Compiling C++ to Vulkan Shaders
- found APLearn: machine learning library
- I Think I’m Done Thinking About genAI For Now

#agent #compiler #debugger #jujutsu #lean #os #rust #sec #software #tla
- Physicality: the new age of UI
    - love it
    - Flat design vs realistic (“skeuomorphic”) design
- jujutsu on tangled
    - it's really powerful to edit a changeset to keep commits/PRs clean and focused, no more frustrating rebasing
    - maybe I'll really start using `jj`
    - related: Example of Splitting a PR
- Why I Think Lean Software Development is Wrong
- How Compiler Explorer Works in 2025
    - learn about nsjail, a lightweight process isolation tool that’s basically a paranoid security guard for processes
- vibe coding
    - Claude Code is My Computer
    - Vibe coding case study: ScubaDuck
- Deep learning gets the glory, deep fact checking gets ignored
- Conformance Checking at MongoDB: Testing That Our Code Matches Our TLA+ Specs | MongoDB Blog
- NLWeb: Protocol for AI-Powered Website Search
    - we really nead a lot of AI-facing protocols, MCP, A2A, NLWeb, `llm.txt` etc.
- Tests should not contain logic
- Script Debugger Retired, IDE for AppleScript

#benchmark #compiler #json #news #os #rust #web #z3
- Fast character classification with z3
- structured error
    - Designing Error Types in Rust Libraries
    - Structured errors in Go
    - Why Use Structured Errors in Rust Applications?
- minimalizing Rust
    - Why am I writing a Rust compiler in C?
    - How to deal with Rust dependencies
    - Reducing Cargo target directory size with -Zno-embed-metadata
- found benchmark-gui
    - from I’m Open-Sourcing my Custom Benchmark GUI
- The DuckLake Manifesto: SQL as a Lakehouse Format
- Progressive JSON
- johncarlosbaez's post on mathstodon.xyz about a viXra branch devoted to AI-assisted papers
- learning speed solving Rubik's cube, see Resources about Rubik's Cube
- Devstral
    - see also devstral-small-2505-mlx
- #aria
    - What I Wish Someone Told Me When I Was Getting into ARIA (on HN)
    - Selfish reasons for building accessible UIs
    - WebAIM: Up and Coming ARIA
        - learn about aria features and roles, it also has demo

#git #lean #neovim #os #sec #tla #zig
- Tools built on tree-sitter's concrete syntax trees
    - found ssr.nvim, Structural search and replace for Neovim, seems more convenient than `ast-grep`
    - should take a look at
        - GritQL
        - srgn
    - found mergiraf, a syntax-aware git merge driver
    - reviewed Quint, a modern and executable specification language, as "an updated take on TLA+"
- My experience so far with Zig – a Go dev’s journey
    - found backstage: an experimental implementation of an actor framework: a great example Zig project using libxev
    - found Zignite: Cross-Platform Graphics Engine
- tao's post on mathstodon.xyz
    - Tao launched a "Lean companion" to his real analysis undergraduate textbook "Analysis I" at teorth/analysis
    - blog post: A Lean companion to “Analysis I”
- Half Spectre, Full Exploit: Hardening Rowhammer Attacks with Half-Spectre Gadgets
    - ProbeHammer, the first crash-free end-to-end Rowhammer exploit that does not rely on templating or massaging
    - monitor a controlled victim’s physical memory activity at the cache line granularity
- found prose: Serve your blog using SSH
- learn 2 new formulas for Rubik's cube, see Test TwistySim and Test Twizzle

#agent #dspy #lean #os #rust
- found C++ to Rust Phrasebook
- Simpler backoff
- Consider Knitting
- Lean-auto: An Interface between Lean 4 and Automated Theorem Provers
    - found Zipperposition
- found Programming Beyond Practices
- investigate DSPy
    - found Agenspy (Agentic DSPy)
    - found attachments
    - found Code Generation with AlphaCodium: From Prompt Engineering to Flow Engineering (code)
        - S*: Test Time Scaling for Code Generation
        - Advances and Challenges in Foundation Agents: From Brain-Inspired Intelligence to Evolutionary, Collaborative, and Safe Systems

#build #formal #rust
- found Grog: the mono-repo build tool for the grug-brained dev
    - then the configuration language Pkl: Configuration that is Programmable, Scalable, and Safe
    - The Grug Brained Developer (2022)
- Rust doesn't actually follow its Golden Rule (when it comes to async functions)
- Parse, don’t validate
    - Names are not type safety (2020)
- When was the last time you broke production and how?

- Why Your AI Coding Assistant Keeps Doing It Wrong, and How To Fix It
- workflows for ai coding
    - interesting take on human attention span
- Compiling a Neural Net to C for a 1,744× speedup

#agent #codegen #gpu #os #proof #render #web
- WebGPU Fluid Simulations: High Performance & Real-Time Rendering
- learn about uzi
    - from LLM Codegen go Brrr – Parallelization with Git Worktrees and Tmux
- A thought on JavaScript "proof of work" anti-scraper systems
- What a Difference a Faster Hash Makes

- found Effekt Language: Home
- The Three Kinds of Money
    - summarized with doubao, then inspired me to work on mermaid and markmap integration
- The two types of open source

#bevy #exif #formal #id3 #news #os #physics #racket #rust #software
- found F2, a bulk renaming tool that supports metadata such as EXIF, ID3 and more
- Idiomatic Rust
    - Don't Worry About Lifetimes
    - Don't Unwrap Options: There Are Better Ways
    - Thinking in Expressions
- found DumPy: NumPy except it's OK if you're dum
    - found einx
        - einx notation is inspired by einops, but introduces several novel concepts such as `[]`-bracket notation and full composability that allow using it as a universal language for tensor operations
- Against Curry-Howard Mysticism
- found Reinforcement Learning: An Overview
- found Modeling Nonlinear Dynamics from Equations and Data — with Applications to Solids, Fluids, and Controls
- found The Ultimate Guide to Fine-Tuning LLMs from Basics to Breakthroughs: An Exhaustive Review of Technologies, Research, Best Practices, Applied Research Challenges and Opportunities
- #game
    - found Pong Wars
        - maybe it's fun to rewrite it in Zig, or with Bevy, possibly in 3D
    - Car Physics for Games
    - Games That Love To Take Things Away From You
    - hammurabi: A Rust recreation of the classic 1968 BASIC game
- I made a font
- Someone rewrote my Zig CLI in Rust? Let's compare!
- found Transformer Copilot: Learning from The Mistake Log in LLM Fine-tuning
    - I've long wished for this kind of meaningful learning, instead of just fine-tuning weights according to loss
- thoughts on software
    - Design Pressure: The Invisible Hand That Shapes Your Code
    - Systematic design of multi-join GROUP BY queries
    - Reinvent the Wheel
    - How to Guarantee Your Red Team Will Fail
    - On File Formats
    - What Works (and Doesn't) Selling Formal Methods

#formal #haskell #lean #ocaml #os #rust #zig
- Having your compile-time cake and eating it too
    - Hindley-Milner (HM), the most popular human-friendly type system, used in Swift, Rust, Scala, Haskell, OCaml etc.
    - proposed four big features to replace pretty much all Rust macros, including derive ones, while keeping Rust's type system, and achieving (most of) Zig's comptime features
        - `@` or `@=`
        - `Abstract`
        - `TypeInfo` and `Field`
        - `Code` and `parse`
- CAPTCHAs don't work any more for ticket sellers
- Concepts vs type traits
- tachy0n: The last 0day jailbreak
- found Domain Theory Lecture Notes
- generate and read the following DeepWiki:
    - ymndoseijin/zilliam
    - ShabbirHasan1/unsynn
    - AstatineAi/ocaml-forester
    - pygae/galgebra
    - utensil/forest
- use GenSpark to generate Follow-up Research after Formalizing Geometric Algebra in Lean
- Does gratitude increase happiness?

#agent #apl #cg #compiler #git #haskell #lean #os #rust #software
- Anthropic’s ‘System Card’ for Claude 4 (Opus and Sonnet)
    - particularly fun reading
        - 4.1.1.1 Continuations of self-exfiltration attempts
        - 4.1.1.2 Opportunistic blackmail
        - 4.1.1.3 Self-exfiltration under extreme circumstances
        - 4.1.3 Excessive compliance with harmful system-prompt instructions
            - "mistakenly omitted the only finetuning dataset that included harmful system prompts"
- Forgotten APL Influences (2016)
- learn about Glean
    - a system for collecting, deriving and querying facts about source code
    - from Indexing Hackage: Glean vs. hiedb
- Pain in the dots
    - different semantics of two and three dot notation for `git log` and `git diff`
- Make Your Phone Grayscale
    - I've already started the practice, combining it with all-day nightshift mode
- The GCC compiler backend can now fully bootstrap the Rust compiler

#ocaml #os #rust #tla
- Why I love OCaml
- How to Get Your Research Paper Accepted
- Fork Union: Beyond OpenMP in C++ and Rust?
- #lang
    - Wren, a small, fast, class-based concurrent scripting language
        - "Think Smalltalk in a Lua-sized package with a dash of Erlang and wrapped up in a familiar, modern syntax."
        - Talon: Write Raylib programs in Wren
    - Picat, a rule-based language, in which predicates, functions, and actors are defined with pattern-matching rules
        - from Finding hard 24 puzzles with planner programming
            - "the only language that I know has a built-in planner module"
    - Dark, a serverless backend language
        - Darklang Goes Open Source
        - Goodbye Dark Inc. - Hello Darklang Inc
    - Roto
        - from Introducing Roto: A Compiled Scripting Language for Rust
    - Janet #lisp
        - a more batteries-included Lua, with Lisp/Clojure-inspired syntax
        - see The smallest embeddable scripting language, part 1
        - PEGs in a PEG
        - JNJ: J iN Janet
        - Bagatto, a static site generator written in Janet
    - goal, embeddable scripting array language
    - lamber, functional scripting language compiling to Lambda Calculus
- found many papers, see some HF papers worth skimming

#context #formal #idea #os
- Adventures in Symbolic Algebra with Model Context Protocol
    - maybe I should create MCP for GAlgebra
    - followup: Interfacing MCP with Combinatorial, Convex, and SMT Solvers
- Transpiler is a meaningless word (2023)
    - maybe that means I should give up on the idea that I could build a Forester transpiler
- found Obsidian Bases

#os #sqlite
- If composers were hackers
- found Litestream: Revamped, making SQLite apps reliably recoverable from object storage
- The Ingredients of a Productive Monorepo

#gpu #news #os #web
- Not causal chains, but interactions and adaptations
    - RCA(root cause analysis) model v.s. RE(resilience engineering) model, for incidents
    - related
        - The same incident never happens twice, but the patterns recur over and over
        - Quick takes on the GCP public incident write-up
            - “What went well” is more than just a pat on the back
            - Behind the scenes: Redpanda Cloud’s response to the GCP outage (on HN) (on lobste.rs)
        - Implicit is better than explicit
- Open Source Can't Coordinate
- Particle Life simulation in browser using WebGPU

#agent #docker #lemmy #mastodon #os
- Agent Recursion
- Semgrep: AutoFixes using LLMs
    - found a few alternatives to `semgrep`, e.g. ast-grep
- Adding Mastodon Comments to your Blog
    - Mastodon as comment system for your static blog
    - My blog now has Lemmy comments
    - learn about Glasp: Highlight the Internet & Build Your AI Clone
- async/await versus the Calloop Model
- Mimalloc Cigarette: Losing one week of my life catching a memory leak
- Ditching Obsidian and building my own
- found Qwen3 Technical Report
- found TestDesiderata
- found macOS VMs in a Docker Container

#apl #compiler #game #gpu #os #physics #quantum #shader #zig
- found Algorithms by Jeff Erickson (2019)
- Comparing parallel functional array languages: Programming and performance[van2025comparing]
    - learned that APL can run on GPU via Dyalog, the paper even discussed a flash attention implementation
    - BQN doesn't seem to run on GPU
    - it might be interesting to use arrayfire C API, even on Mac
    - prefer tilelang to DaCe
- found A JavaScript library for building parsers, interpreters, compilers, and more
- Layers All The Way Down: The Untold Story of Shader Compilation
    - introduces the motivation behind MojoShader, from Direct3D HLSL bytecode or assembly source to other shader languages
- found Mystical, a programming language that resembled magical circles
- Bare Metal Zig (2023)
- Google Scholar is manipulatable
- found Path Integrals in Quantum Mechanics, Statistics, Polymer Physics, and Financial Markets by Hagen Kleinert

#elixir #game #ocaml #os #rust #software #web #zig
- Parallel Scaling Law for Language Models
- #lang
    - The Language That Never Was
        - Leaving Rust gamedev after 3 years
        - Mun
        - jank
        - The Little Book of Rust Macros
        - MonoGame
- #rust/error
    - Using unwrap() in Rust is Okay
        - anyhow for applications and thiserror for libraries
    - On Error Handling in Rust
        - error_set, inspired by Zig's error set
        - snafu
- found GNU Parallel Examples
- found Lua for Elixir
- found OCaml Web Development: Essential Tools and Libraries in 2025
- found Teal: a statically-typed dialect of Lua, a statically-typed dialect of Lua

#formal #game #news #os #rust #tla #zig
- I don’t like NumPy
    - Writing a better code with pytorch and einops
    - Einops and Einsum Summarized
- looking for Zig way to implement eiops
    - Interesting (mis-)use cases for comptime
        - zig-infix-parser
    - Zig Comptime is amazing
        - ZEIN, Zig-based implementation of general-rank tensors
        - Functional Programming in Zig
        - What is Zig's Comptime?
        - comath: comptime math, used by zilliam
        - alg, Algebra for Zig
        - mecha, A parser combinator library for Zig
            - from Zig, Parser Combinators - and Why They're Awesome
        - parcom, see also this blog post
    - einops in Rust, with only backend `tch`
    - Einsums and einops-cpp are in C++
- The current state of TLA⁺ development
    - found Spectacle and tlafmt
- 10 Years of Stable Rust: An Infrastructure Story
    - formal methods projects built on Rust
- Beyond 'Aha!': Toward Systematic Meta-Abilities Alignment in Large Reasoning Models
- Declaring a friendship to self
- Internet Artifacts
    - discovered Helicopter game

#formal #forth #os #tla #zig
- Introducing oniux: Kernel-level Tor isolation for any Linux app
    - code
    - found smoltcp
- The cryptography behind passkeys
- How fast is CeTZ-Plot?
- ZJIT has been merged into Ruby
    - Instead of compiling YARV bytecode directly to the low-level IR (LIR), it uses an high-level SSA-based intermediate representation (HIR)
        - In the bytecode, which is tersely encoded, jumps are offsets, some control-flow is implicit, and most dataflow is via the stack.
        - By contrast, HIR looks more like a graph. Jumps have pointers to their targets and there’s no stack: instructions that use data have pointers directly to the instructions that create the data.
- found Warteschlangensimulator, a event-driven, stochastic simulator for queueing systems
- found kowk, a ~100k-pod k8s cluster simulator
- Data is code, about philosophy behind Forth
    - also What the hell is Forth?
- found Insights into DeepSeek-V3: Scaling Challenges and Reflections on Hardware for AI Architectures
- found Marigold: Affordable Adaptation of Diffusion-Based Image Generators for Image Analysis
    - Marigold Computer Vision
- Zig App Release and Updates via Github ⚡

#agent #ebpf #os #physics #rust #software #tui #web #yaml
- try genspark
    - impressive result
    - one deep research per day for free
- Read the Code, Not the Profile
    - Dramatic percentages in software is just linear improvement
- Writing that changed how I think about PL
- Experiment on your code freely with Git worktree
- Lock-Free Rust: How to Build a Rollercoaster While It’s on Fire
- found
    - Spall: a code profiler that runs in your browser
    - TUI for search & replace
        - scooter: Interactive find and replace in the terminal
        - serpl: A simple terminal UI for search and replace, ala VS Code.
        - scooter wins as it supports filtering files, both support regex and replace preview
    - Avian Physics 0.3
    - Makepad 1.0 : Rust UI Framework
- checked out YS — YAML Done Wisely
    - I wish to use it as a template engine, but the scripting syntax is not delicious
- Two months in Servo: CSS nesting, Shadow DOM, Clipboard API, and more
    - Servo is still very actively growing
- Misadventures in DTrace: how to debug the macOS kernel
    - I need to compare more with eBPF and DTrace
    - found DTrace book

#apl #formal #os #proof #rust #sec #tla #web
- Are We Serious About Using TLA+ For Statistical Properties?
    - found FizzBee for behavior correctness verification and performance modelling, based on simulation
    - I've wished for a tool like this for a long time
    - see also Modular verification of MongoDB Transactions using TLA+
- Flattening Rust's Learning Curve
    - The best open source project for someone might not be yours, and that's OK
- A review of documentation in the Rust ecosystem
    - found Blessed.rs: Recommended Crate Directory
- Secure by Design: Google’s Perspective on Memory Safety (2024)
- Microservices Are a Tax Your Startup Probably Can’t Afford
- Private Internet (2024)
- A tool to verify estimates, II: a flexible proof assistant

#os #rust #zig
- Memory Safety Features in Zig
    - very well summarized, with great examples
- Reservoir Sampling
- You can use C-Reduce for any language
- Rust Dependencies scare Me
    - a comment reminds me of Build It Yourself
- What's in an e-graph?
- A catalog of ways to generate SSA

#agent #gpu #idea #interop #os #software #web #zig
- Why transformers need adam: A hessian perspective[zhang2024transformers]
    - insightful, and well summarized related work
- trying to figure out a way to let AI agent to read all papers citing an paper, and write a summary of the follow-up research
- The magic of software; or, what makes a good engineer also makes a good engineering organization
    -  "Engineers are most capable and most effective when abstraction layers serve as shorthand for an understanding of what it is doing on your behalf, rather than a black box"
    - "start with deep understanding as the basis for innovation – cultivating the curiosity to look inside the black boxes"
    -  "The magic of both software and software organizations comes from those moments where insight into how something works sparks entirely new ideas about what it could become"
    - related: Reinvent the Wheel
- Implement your language twice
    - Futhark is a statically typed, data-parallel, and purely functional array language with AoT compilation to CUDA, OpenCL, HIP, and WebGPU (WIP)
    - also Comparing the performance of OpenCL, CUDA, and HIP
- Objective-C interop with Zig?
- got zig to work inside lima with minimal setup

#os #rust #tui #web #zig
- Zig’s Low-Level Safety Features Leave Rust in the Dust
- Zig defer Patterns
- Glossary Web Component
- Recreating an iOS Animation with GLSL (interactive tutorial)
- found Argo CD - Declarative Continuous Delivery for k8s
- found bash/POSIX-compatible shell implemented in Rust
- found nnd: A TUI alternative to gdb

#ebpf #os #rust #tui #zig
- Zig’s Low-Level Safety Features Leave Rust in the Dust
- found Parallel, Concurrent and Distributed Programming in Scala
- found nnd: A TUI alternative to gdb
- found A part of the fundamental group of an n-dimensional beanA
- Building a regex engine in C++
- wondering about chaos engineering in Zig with eBPF #ebpf
    - learn more about zbpf
    - maybe it's easiest to use lima to test eBPF
    - found Pixie when reading Debugging Production: eBPF Chaos
    - Introducing Minderbinder which is in Go
    - Implementing fast TCP fingerprinting with eBPF
        - using Cilium in Go
    - ebpf series - Unnamed Memories
    - Introducing TCP-in-UDP solution (eBPF)
    - Go Allocation Probe (on HN)
    - KernelScript eBPF-centric programming language (on HN) #lang
    - OOMProf - Take a heap profile just before OOMkill using eBPF #chaos
- found alternative open source front-ends for popular internet platforms

#agent #benchmark #blogging #context #formal #game #gpu #news #optimization #os
- LM
    - survey papers
        - A Survey on Inference Engines for Large Language Models: Perspectives on Optimization and Efficiency
        - Low-Precision Training of Large Language Models: Methods, Challenges, and Opportunities
            - sadly, NormalFloat used by QLoRA is excluded from the paper, as it is "specifically designed for pretrained fixed parameters, which only participate in the forward inference stage during training."
    - improvements on reasoning
        - Think on your Feet: Adaptive Thinking via Reinforcement Learning for Social Agents
            - the model is trained to switch between different complexity level of thinking mode based on context for an optimal balance between correct answer and reasoning length
            - the thinking modes are inspired by Hierarchical Cognitive Control Theory (HCCT)
        - RM-R1: Reward Modeling as Reasoning
            - provides good insight into reward modeling and how each training stage boosts the model's performance
    - other
        - Unlearning Sensitive Information in Multimodal LLMs: Benchmark and Attack-Defense Evaluation
            - I'm still interested in unlearning and model editing
- Benchmarking Crimes Meet Formal Verification
    - learn about Systems Benchmarking Crimes
- #zig
    - Implementing a Struct of Arrays
        - Zig has easy-to-use support of SoA via MultiArrayList
        - learn about Data-Oriented Design
        - I can't help but feel that new features of C++ such as reflection is really becoming syntax cancer
    - Reflecting on a year of Gamedev in Zig
    - Jai, the game programming contender
- bringing data to AI, not the other way around
    - The Data Surrender Trap: How Enterprises Are Losing Control in the AI Gold Rush—and the Simple Fix
- lifestyle
    - Protect The Habit
    - skimmed blogging in isolation
- skimmed modern-latex: A short guide to LaTeX that avoids legacy cruft
- The Beauty Of Having A Pi-hole
    - own your own DNS
- An appeal to Apple from Anukari regarding GPU frequency scaling
    - I'm amazed that the author is using GPU to simulate physics for realtime audio

#git #interop #lean #os
- found pyonji, a tool to support sr.ht style e-mail patches
- Git: programmatic staging
    - and learn about `grepdiff`, unfortunately, it's not available on Mac
    - `git add -p` is also acceptable for a small number of hunks
- MathML with Pandoc
- Starting on seamless C++ interop in jank
- found Anemll: Artificial Neural Engine Machine Learning Library

#formal #os #web
- DeepSeek-prover-V2: Advancing formal mathematical reasoning via reinforcement learning for subgoal decomposition[ren2025deepseekproverv2]
    - A survey on post-training of large language models[tie2025survey]
        - notes on LM could be based on this survey and the following papers related to r1
    - 100 days after DeepSeek-R1: A survey on replication studies and more directions for reasoning language models[zhang2025days]
        - Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning[guo2025deepseek]
            - should revisit
    - found critics of r1/GRPO
        - Understanding r1-zero-like training: A critical perspective[liu2025understanding]
        - Does reinforcement learning really incentivize reasoning capacity in LLMs beyond the base model?[yue2025does]
    - Kimina-prover preview: Towards large formal reasoning models with reinforcement learning[wang2025kimina]
- found A Survey of Interactive Generative Video
- Polishing your typography with line height units
- Solving Sudoku with Algebraic Geometry and Computer Algebra : A C Programming Approach

#apl #formal #lean #os #prolog
- found Leanabell-prover: Posttraining scaling in formal reasoning[zhang2025leanabell]
- skimmed Flow matching guide and code[lipman2024flow]
- APL: Comparison with Traditional Mathematics
- I use Zip Bombs to Protect my Server
- found Prolog Notes
- found Quotes on notation design & how it affects thought

#agent #os #✍️
- found A Dependently Typed Assembly Language
- Qwen3: Think Deeper, Act Faster
- found Topologies and Sheaves Appeared as Syntax and Semantics of Natural Language (2012)
    - reveals connection between sheaf theory and linguistics
- found On the expressivity role of LayerNorm in transformers’ attention[brody2023expressivity] [code]
- found Grammar prompting for domain-specific language generation with large language models[wang2023grammar]
- wrote My setup with 4 screens and 2 Macs

#compiler #llvm #os #zig
- BitNet v2: Native 4-bit Activations with Hadamard Transformation for 1-bit LLMs
- Converting a C API to Zig with the help of comptime
- How a Single Line Of Code Could Brick Your iPhone
- found Nouveau: The Rule Based Language Family
    - and easily got into an infinite loop by adding a rule trying to combine a match and a box back to a matchbox
- Technical Debt as Theory Building and Practice
- Using HAProxy to protect me from scrapers
- What if we embraced simulation-driven development?
    - Notes about ETCD, there are some war stories
    - Notes about Raft's paper
- toycalculator, an MLIR/LLVM compiler experiment.

#apl #news #os #web
- found APL Cultivations
- found Dive into Systems (2020)
- found Smallweb – Your Internet Folder
- found Cognition's DeepWiki, a free encyclopedia of all GitHub repos

#benchmark #compiler #formal
- found Mitata - a beautiful benchmarking tool
- Nofl: A Precise Immix
- O(no) You Didn’t
- found PyGraph: Robust Compiler Support for CUDA Graphs in PyTorch

#bevy #gpu #idea #news #os #render #sec #software #tla #wasm
- Bevy 0.16
    - learn about GPU-Driven Rendering and WESL
- How I Got Hacked: A Warning about Malicious PoCs
- MCP Security: Tool Poisoning Attacks
- The ‘trickonometry’ of math olympiad inequalities
    - intriguing write-up, well collected problems, insightful perspective
    - found My list of challenging software projects some programmers should try
- Towards Vortex 1.0
    - a next-generation columnar format with self-describing layouts and WASM decoders that is 200x faster than Parquet for random access, among other goodies

#diagram #duckdb #gpu #idea #llvm #optimization #os #tla #wasm #✍️
- Abusing DuckDB-WASM by making SQL draw 3D graphics (Sort Of)
    - a very cool idea
    - I should learn more about modern databases
- found Bluefish
    - a JS diagram library with quite some potential
    - some teaser examples were added by this commit
- Exploiting undefined behavior in c/c++ programs for optimization: A study on the performance impact[popescu2025exploiting]
    - so there are actually many performance-wise well defined UBs in LLVM
- GPU Compilation with MLIR
    - found MLIR Python Bindings
- skimmed Some possible roles for AI of Grothendieck topos theory by Laurent Lafforgue (2022)
- made a start on improving PDF organization in and out of MarginNote
- looked for ways to manipulate iCloud files programatically
    - noticed that `rclone` supports iCloud too
    - but `~/Library/Mobile Documents/com~apple~CloudDocs` already works well for my purpose

#elixir #os #rust #zig
- Nine Reasons to Use OSH
    - it contains a POSIX-compatible shell `osh`, and an incompatible shell `ysh`
    - it's written in a subset of Python, then transpiled to C++ by mycpp that is based on MyPy, an interesting approach
- found codapi which supports sandboxes for Rust, Zig, Elixir etc.

- Make Your Own Internet Presence with NetBSD and a 1 euro VPS – Part 1: Your Blog
    - which uses BSSG, a simple static site generator written in Bash
    - will settle on UTM for Mac/BSD virtualization, and Lima for Linux virtualization
    - still haven't figure out how to virtualize/emulate NetBSD with UTM, see this issue
- My Dev Workflow: 2025
    - found and started using Loop

#context #elixir #idea #os #render #rust #web #z3 #zig
- wish to learn more about other architectures of LMs, e.g.
    - BitNet b1. 58 2B4T technical report[ma2025bitnet]
    - d1: Scaling reasoning in diffusion large language models via reinforcement learning[zhao2025d1]
    - M1: Towards scalable test-time compute with mamba reasoning models[wang2025m1]
    - RWKV7-G1 "GooseOne" reasoning model, see Rwkv-7 "goose" with expressive dynamic state evolution[peng2025rwkv]
    - ModernBERT, see Smarter, better, faster, longer: A modern bidirectional encoder for fast, memory efficient, and long context finetuning and inference[warner2024smarter]
- The State of Reinforcement Learning for LLM Reasoning: Understanding GRPO and New Insights from Reasoning Model Papers
- Lorenz and modular flows: a visual introduction which is "deep, beautiful and with a taste of singularity and knot theory"
    - found Ultra Fractal 6 and POV-Ray
- found less_slow.cpp: Playing Around Less Slow Coding Practices for C++, CUDA, and Assembly Code
- found Common Expression Language
- How I use Kate Editor
- watched Implicit Surfaces (using interval arithmetic to evaluate SDFs)
    - PDF Slides
    - the ideas behind Fidget and Massively parallel rendering of complex closed-form implicit surfaces[keeter2020massively] well explained, GOAT-level inspiring
    - should be further explored in Notes on ray-marching implicit surfaces
    - there are also many interesting writeups in The Prospero Challenge
- Things Zig comptime Won't Do
- #gleam
    - Gleam that has a Rust-like syntax, runs on Erlang VM, and supports compiling to JavaScript
    - My First Impressions of Gleam
    - Gleam for Elixir users
    - Lustre
        - a web framework in Gleam
- note more about Taiji and practice more

#elixir #formal #os
- Common shell script mistakes
- Four Years of Jai
- My journey from Ruby to Elixir: lessons learned
- Revisiting an early critique of formal verification

#gpu #os #zig
- found Matrix Calculus for Machine Learning and Beyond
- Reflections on Unikernels
    - found OSv
    - revisit Seastar, a C++ server framework that uses a shared-nothing model
- Stop Writing `__init__` Methods
    - for potential gotchas, read also Python dataclasses, a package full of surprises
- Weird / irritating build issue with raylib
    - so I should also start using the new hash format
- Zig and GPUs

#agent #news #os #rust #sec #tui #zig #✍️
- found A practical hacker's guide to the C programming language
- An Intro to DeepSeek's Distributed File System
    - my takeaway: DeepSeek's 3FS sacrifices small-file performance, POSIX compatibility, and fault tolerance (single-master risk) to maximize large-file throughput via CRAQ-based chain replication and RDMA-optimized chunk writes on 512B-sector SSDs
- Development On Apple Silicon with UTM
    - cloud-init
    - Windows ARM64 Download | MAS #win
- TLS Certificate Lifetimes Will Officially Reduce to 47 Days
- found Torque – A lightweight meta-assembler for any processor
- found Unsure Calculator
- Zigistry about to reach 300 stars on GitHub ⭐️
- [AINews] OpenAI o3, o4-mini, and Codex CLI
    - and particularly codex: Lightweight coding agent that runs in your terminal
- the lifecycle of a pull request and tried to login to https://tangled.sh/
- learned about `std::autodiff` in Rust via `Enzyme`
- converted some of my playlist to Youtube Music and scrobble them to libre.fm
    - found also cmus, a TUI music player that plays from local files, and supports scrobbling
- wrote some more Taiji notes

#dspy #tla #tui #web #webgl #zig
- A flowing WebGL gradient, deconstructed
- found An Introduction to Modern CMake
- JSX Over The Wire
- found ax, DSPy in TypeScript
- looked for HEIC libraries in C that can be used in Zig
- found WebTUI
- found Terminal Trove, a collection of terminal-based applications

#compiler #optimization #os #render #rust
- A 2025 Survey of Rust GUI Libraries
- Algebraic Semantics for Machine Knitting
    - further reading:
        - Semantics and scheduling for machine knitting compilers[lin2023semantics]
- C++20 idioms for parameter packs
- skimmed Flat origami is turing complete[hull2023flat]
- Pretty State Machine Patterns in Rust
- Implementing GRPO
- found Networking Research Resources
- found TeX.social: a feed aggregator for LaTeX-related sites, especially blogs.
- A 2025 Survey of Rust GUI Libraries
- learn about AerynOS
- Algebraic Semantics for Machine Knitting
- C++20 idioms for parameter packs
- Flat origami is Turing complete
- Frontier AI Models Still Fail at Basic Physical Tasks: A Manufacturing Case Study
- Procedural Foliage Rendering with L-systems and Geometry Instancing
- What the Hell Is a Target Triple?
- try converting some playlist to Spotify with TuneMyMusic
    - screenshot, VLM OCR, then text to playlist
    - Spotify doesn't always have the songs, even if manual search, e.g. some songs before 2017
- thinking about Graph RAG, and found HelixDB, a graph-vector database

#rust #visualization
- A Visual Journey Through Async Rust
    - and it would be insteresting to see the visualization for `monoio`
- Solving One Million Sudoku Puzzles per hour in Swift

#compiler #ebpf #elixir #lean #tui #zig
- looking for Zig libraries for TUI, `io_uring`, eBPF, scripting, e-graph
    - the candidates are `libvaxis`, `libxev`, `zbpf`, `Cyber`, `zegg`, respectively
- found Juniper CAS, which is exactly my original dream for lean-ga
- found Beaver: MLIR Toolkit in Elixir and Zig.
    - one relevant application is Manx
- Building a high-performance database buffer pool in Zig using io_uring's new fixed-buffer mode
- How io_uring and eBPF Will Revolutionize Programming in Linux
- found Performance Analysis and Tuning on Modern CPUs

#cg #compiler #elixir #gpu #rust #shader #software #tla
- Bootstrapping Understanding: An Introduction to Reverse Engineering
- Bug in Outlook PST Password Protection (2006)
- Erlang’s not about lightweight processes and message passing…
    - further reading: Making reliable distributed systems in the presence of software errors[armstrong2003making]
- found Rust to C compiler - 95.9% test pass rate, odd platforms
- Shadertoys ported to Rust GPU
- Build a Static Site in Elixir Under 5 Minutes with Phoenix Components while looking for SSG in Elixir

#agent #software
- 12-factor-agents: Principles to build LLM-powered software good enough to put in the hands of production customers
- found cargo-mutants: Inject bugs and see if your tests catch them
- found DeepCoder: A Fully Open-Source 14B Coder at O3-mini Level

#elixir #os #rust
- Archiving URLs
    - maybe I should use tools like ArchiveBox to prevent link rot
- Mistakes and cool things to do with arena allocators
- found shorty: a C++ library for concise lambdas
- Parser Combinators Beat Regexes
- found facet: Rust reflection, serialization, deserialization — know the shape of your types
    - thus found unsynn: a minimalist rust parser library
- $handle_undefined_function in Elixir/Erlang
- found Twee, an equational theorem prover again
    - from Automated Equational Reasoning with Twee Pt 1.

#compiler #neovim #os #render #rust
- Beautiful CI for Bazel
- found Real-Time Rendering Resources
- The Gamma Knife model of incidents (2019)
- Thinking like a compiler: places and values in Rust
- Writing good comments: the why, not the how (2020)
- My neovim markdown setup in 2025

#✍️
- Model error
- wrote 4 bugs caught me off guard recently

#os #rust
- Atproto Ethos
- BPF From Scratch In Rust
- Pitfalls of Safe Rust

#lean #news #os #rust #simd #web
- Of manners and machines
- Rewriting my site in vanilla web
    - TAC: A new CSS methodology
    - Blinded By the Light DOM
    - maybe I should rewrite most of my customizations to forest markup as web components
- Vector Sets are part of Redis
- Towards fearless SIMD, 7 years later
- Introduction to Monoio: A High-Performance Rust Runtime
- found Public mdBooks

#biology #lean #rust #tui #web
- learn about geonum, a ridiculously fast Rust library that supports many GA operations except for geometric product
- some portions of On the Biology of a Large Language Model
    - it's a particularly inspiring article on the interpretability of LLMs
    - it's authored with Distill Template, see guide
    - similarly, found World Models
- A Year of Rust in ClickHouse
- AI ambivalence
- Minimal CSS-only blurry image placeholders
- found chawan: TUI Web Browser

#formal #os #sec #web
- Stop syncing everything, which launches Graft, an open-source transactional storage engine optimized for lazy, partial, and strongly consistent replication—perfect for edge, offline-first, and distributed applications.
- The Most Amusing Security Flaws I've Discovered
- Foundation Models and Unix
- Goodbye Offpunk, Welcome XKCDpunk
- Hello Quarto: Porting my Website from Hugo Apéro
- found Interaction nets
- Programming with an AI copilot: My perspective as a senior dev
- found Testing Distributed Systems
- found
    - Mathematical theory of deep learning[petersen2024mathematical]
    - Beyond limited data: Self-play LLM theorem provers with iterative conjecturing and proving[dong2025beyond]
    - Dapo: An open-source llm reinforcement learning system at scale[yu2025dapo]

#os #rust
- There is no Vibe Engineering
- found Koto Programming Language, it's not so DSL-friendly like Rhai, but a reasonably good script language embeddable in Rust
- Thoughts on ECS
- Expressing Japanese Grammar Through TypeScript Type System
    - I really wanted this for French, except for not in TypeScript, but something Rust-like

#agent #idea
- work on exporting Discord chat and feeding them to RAG, the result is not quite ideal
- try DeepSeek-v3-0324, but still not as good as Claude 3.5 for my use cases
- re-evaluate marimo as an alternative to testing with Jupyter notebooks
    - but it doesn' store outputs, and the candidate testing solution is not elegant

#os #rust #✍️
- found
    - Learning theory from first principles[bach2024learning]
    - Winding numbers on discrete surfaces[feng2023winding], and read the blog post
    - Simulating time with square-root space[williams2025simulating]
- found Xee: A Modern XPath and XSLT Engine in Rust which could be used to process Forester XMLs in the future
- found The Mean-ing of Loss Functions
- wrote Fragmented learning, no more

#elixir #news #os #rust #zig
- learn more about Elixir
    - Running ML models in Elixir using Pythonx
    - Embedded Zig with Elixir, Mandelbrot set
    - Rustler Precompilation guide
    - learn about axon and the Numerical Elixir (Nx) ecosystem
- Why MCP Won

#os
- slowly picking up open-source work, after fragmented learning due to the DeepSeek hype
- found PeanoScript, TypeScript but a theorem prover
- attention is logarithmic, actually
- The willing kingdon clifford algebra library[roelfs2025willing], the Kingdon paper

#ocaml #os #racket #tui
- found Rhombus, a Racket without parenthesis
- Writing a SIGGRAPH paper (for fun) (2020)
- The 70% problem: Hard truths about AI-assisted coding
- learn about owi: Cross-language Bugfinder
- found Reinforcement learning: An overview[murphy2024reinforcement], some ML books by the same author are on Github
- found Intuitive topology[prasolov1995intuitive]

- learn about Minimal algorithms for lipschitz monoids and vahlen monoids[helmstetter2013minimal], a paper about determining whether a multivector is a versor, as versors are invertible lipschitzian elements, related to galgebra#533

#agent #category #lean #os #proof #quantum #sec
- found
    - Math
        - Category Theory Illustrated
        - Introduction to gauge theory[haydys2024introduction]
        - A gentle introduction to categorical logic and type theory[schmid2025gentle]
        - A lean and mean introduction to modern general relativity[hayman2024lean]
        - Knot theory[fushida2020knot]
        - Introduction to representation theory[etingof2024introduction]
        - A first course in topos quantum theory[flori2013first]
        - PLP - An Introduction to Mathematical Proof [source]
    - ML
        - Demystifying Diffusion Models
        - Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning[guo2025deepseek]
        - Camel: Communicative agents for" mind" exploration of large language model society[li2023camel] for Owl

#rust #zig
- found some readings for Rust and Zig, see native-land commits

#raymarching #rss
- Raymarching The Gunk

#agent #codegen #news #proof #typst #z3
- Uncensor any LLM with abliteration
- All the Transformer Math You Need to Know
- [AINews] Claude 3.7 Sonnet
- learn about Typst 0.13 is out now: Experimental HTML export, semantic paragraphs, and more
- Where are all the Rewrite Rules?, using Knuckledragger, a down to earth, highly automated interactive proof assistant in Python, based on Z3
- My LLM codegen workflow atm
- found The FFmpeg School of Assembly Language
- Serving local LLMs with MLX
- Enough with all the Raft

#news #typst #✍️
- busy with Spring Festival
- WeRead books and wrote some reviews
- casual readings are starred in NetNewsWire
- learn stuff related to DeepSeek and MLX
- set up my new Mac Mini with M4 Pro, Logi MX Keys, MX Master 3, and 4 screen working environment
- organize my Chinese ancient poetry collection (in LaTeX, wishing to port to Typst in the future)

#os #physics #quantum #render #rust #zig
- articles on lobste.rs
    - Elementary Water Rendering
    - Prototyping in Rust
    - Go is a Well-Designed Language, Actually v.s. Why Go Should Sometimes Be a No-Go
    - Zig's Comptime is Bonkers Good
    - Not every user owns an iPhone
        - First Contentful Paint (FCP)
        - Time To Interactive (TTI)
        - Interaction to Next Paint
    - The Most Elegant Configuration Language
- found Lectures on topos quantum theory[flori2012topos]
    - Applications of topos theory to quantum physics[bielas2023applications] can provide some motivation and applications
        - gutta cavat lapidem non vi, sed saepe cadendo
- wish to write more serious Zig in new year, found Mach
- found *Histoire de la philosophie* by Émile Bréhier

- 📦 move to new office and get used to everything
- 🗓️ making plans for the new year