- #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)
    - Omarchy, a Linux Distribution by DHH (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)
    - Electric bikes might just be the healthiest thing to ever happen to teenagers (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/
    - Backpropagating through a maze with candle and WASM #disect #game
    - 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