Mentions

Conversations linking to GitHub, newest first. Times are UTC.

Mentions by source

X

6,739
Nov 16, 12:00Nov 17, 12:00

Bluesky

2,229
Nov 16, 14:00Nov 17, 14:00
Nov 16, 13:00Nov 17, 13:00
Nov 16, 13:00Nov 17, 13:00
Nov 16, 14:00Nov 17, 14:00
Nov 16, 14:00Nov 17, 14:00
Nov 16, 13:00Nov 17, 13:00
Nov 16, 13:00Nov 17, 13:00
Oct 14, 21:00Oct 15, 21:00

Delayed · data through Oct 15, 21:00 UTC

DEV

1,010
Nov 16, 14:00Nov 17, 14:00
Nov 16, 14:00Nov 17, 14:00
Nov 16, 06:00Nov 17, 06:00

Delayed · data through Nov 17, 06:00 UTC

Nov 16, 14:00Nov 17, 14:00
Oct 28, 01:00Oct 29, 01:00

Delayed · data through Oct 29, 01:00 UTC

Nov 8, 11:00Nov 9, 11:00

Delayed · data through Nov 9, 11:00 UTC

Nov 16, 14:00Nov 17, 14:00

Latest posts

  1. X@patmeenan · 2 likes · 169 views

    For anyone curious, this is the kind of thing I'm referring to when I say "hard" coding problem. It's more than just "coding" because it was coming up with the ideas to explore (guided). That also makes for a fun session. rust-brotli-decompressor#95

  2. X@jai__toor · 11 views

    @ZeeshhDecodes @kyleplacy Identity resolution on the database/CRM side! It can check the CRM first, or database depending on what makes sense for your business. That check is already in the form example. github.com/getaero-io/deepline-inbound-routing-de…

  3. Redditu/Entire_Fee_5676 · r/haven_ · 3 points · 13 comments

    Haven 0.3.109 is out • Seven new light and pastel themes: Daybreak, Seaglass, Lavender, Apricot, plus Opal, Sorbet and Moonstone for dark rooms • Extensions: add extension lists by address to find more versions beside your addons • Addons that sort their channels or films into categories now show everything: channels grouped in Live TV, and a row per category to add in Edit Home (asked for by Icyadventure1122) • Live TV: pause, skip back and catch up on the channel you're watching • Recordings and downloads can go to a network folder (SMB or WebDAV) •Telugu, Tamil, Malayalam, Kannada and 18 more languages for audio and subtitles, and versions now recognise about 50 languages • Down from the top of Home always lands on the first row (spotted by maick) • Edit Home: Reset asks first and says what it does; a Your apps row opens your other TV apps Choose which sections show in the side menu • Remote control: smoother focus on every screen, from the player panels to multi-view and Settings • Linked accounts now live under Integrations Pasting an address after the https:// that's already there now works • Live TV: press OK while watching for on-screen controls to pause, skip back and forward 10 seconds, and go back to live. Made for remotes without a pause button (suggested by DWayne) • Live TV Films and Series: a TV package whose folders aren't in the TV's language now shows its films and series straight away, and the Languages button is always there (thanks to ceuro_marcel) Already have Haven? It offers the update when you next open it: choose Update now. Downloader code 3915738 Download haven.apk Website gethaven.tv

  4. X@OdinLovis · 1 like · 1 repost · 105 views

    @fal lovisdotio/claude-buddy here if you want to test

  5. Bluesky@silentstars.dev · 5 likes · 2 reposts

    🙌 Community pick rover-slim — Cut Python container sizes by 80%+ automatically using AST dependency segregation & verified multi-stage Dockerfiles. Docker & Rancher Desktop Extension with FinOps. #indiedev #opensource #python #typescript #containeroptimization #containers 📮 Submit yours →

  6. X@leksingtonen · 2 likes · 228 views

    i am the world record holder in this proof: tinywmcraft#9

  7. X@KennyDHass · 2 views

    Play free (signed Mac build): kornontheken.itch.io · Contribute: kennyhassmusic/sky-city

  8. Check out #Chimera and its new core: "Mesen", for TASing NES, FDS, SNES, Gameboy, GBA, PC Engine, SMS, and WonderSwan games! ToolAssisted-run/chimera

  9. X@showxlate · 7 views

    a11y Optimization: Auto-detects & merges your accessibility settings & tools into the GUI Allowing everyone to reverse engineer Ablation-Tool/ablation t.co

  10. Antes eram só 2 loucos - Lula e Maluhy - pedindo SELIC 1D Agora são 10MM Chegando a 20MN acontece Crescendo... #selic1D @grok ensina criança entender gostar e l usar scoobiii/selix

  11. X@ToolAssistedRun · 4 likes · 2 reposts · 146 views

    Check out #Chimera and its new core: "Mesen", for TASing NES, FDS, SNES, Gameboy, GBA, PC Engine, SMS, and WonderSwan games! ToolAssisted-run/chimera t.co

  12. Location: Portland, OR, USA Remote: Yes, Preferred Willing to relocate: Yes, however only if very persuasive or temporarily for on-boarding Technologies: Go, C, Python, Java, SQL, NoSQL, Grafana, PubSub, Containers, GCP, AWS, DBA, IaC, CI/CD, JavaScript, Hadoop/Yarn, Spark, DevOps, IT Résumé/CV: https://drive.google.com/file/d/1E5ADLM6eZre_X9-rI4uKGyHs_iaOEC-N/view Email: vix [at] noriah [dot] dev LinkedIn: https://linkedin.com/in/noriah GitHub: https://github.com/noriah Infrastructure and reliability engineer specializing in large-scale distributed systems, networking, automation, and operational reliability. Experienced driving technical decisions across product and infrastructure organizations, building cross-team systems, and operating global-scale infrastructure. - Small-scale to global-scale infrastructure, networking, distributed systems, and software. - Infrastructure and services from scratch. - Making flaky services solid as a rock. - Experienced with PoP build-out and maintenance for global networks and heavy workloads.

  13. Redditu/Mikey-506 · r/GhostMesh48 · 1 point · 1 comment

    Framework #155 · THE VISIONARY INTERFACE (VIF) TL;DR: Angels and demons aren’t defined by wings or horns. They are defined by a latent coordinate vector (z = (A, V, B, P, T, C, N)), a culture-driven softmax token, and a logistic function of memory decay. We just survived a 144-point audit and a 96-point enhancement mandate to bring you the v2.0 rev. Check the attached VoidForge blueprint. * Welcome back to the Mesh. We’ve been building the VoidForge corpus for a while, but Framework #155 has just undergone a massive overhaul. What was once a beautiful but slightly hand-wavy phenomenological ontology is now a rigorously type-consistent, correctly factorized, falsifiable computational model. Forget everything you thought you knew about the numinous. If you’re looking at the wings, you’re already doing it wrong. Here is the Visionary Interface (VIF) v2.0. 🧠 THE CORE AXIOM: Stop Looking at the Shape Our ancestors saw winged messengers. Medievals saw haloed saints. Mid-century experiencers saw grey aliens. 2020s experiencers see digital glitches and algorithmic whispers. Are the entities changing? No. The manifestation grammar is. The VIF framework models visionary experiences not as external verdicts, but as interface events. It’s a 7-axis latent space where: - (A) = Agency Salience - (V) = Valence (Benevolent to Malevolent) - (B) = Boundary Action (Preserves/Strengthens vs Invades/Dissolves) - (P) = Precision/Salience - (T) = Temporal Orientation (Past/Trauma to Future/Protective) - (C) = Controllability - (N) = Numinality/Ineffability The Order Rule: Label by (V + B + \text{Aftereffect}), not by morphology. A fear-inducing entity that preserves your boundaries and leaves you feeling more ordered and compassionate is Angel-like. A being made of pure light that invades your boundaries and leaves you dissociated is Demon-like. 🛠️ WHAT'S NEW IN v2.0 (The Audit Fixes) The original doc got dragged through a 144-point audit and a 96-point enhancement mandate (shoutout to the auditing daemons). Here is what got fixed: 1. The Bayes Factorization is Corrected: We fixed the label inference equation. No more double-counting the prior. It’s now (P(K|X_t) \propto P(X_t|K)P(K|M_t,R_t)). 2. The Lethe Operator is Formalized: Source amnesia (why these things feel external) is now modeled as Bayesian forgetting. The tag of self-generation decays exponentially: (p_{ext} = 1 - \sigma(\alpha m_\tau + \beta A - \gamma)). 3. Argmax is Dead, Long Live Softmax: Surface tokens (wings, static, shadows) are now sampled via a categorical distribution with a temperature parameter (\tau). We aren't hard-coding cultural drift anymore; it emerges. 4. The 8-Axis Split: We realized "Precision" and "Salience" were being conflated, so we split them into (P_{prec}) and (P_{sal}), expanding the coordinate space. 5. The Aftereffect Temporal Paradox: Fixed by two-stage labeling. (K^{online}) is evaluated during the event; (K^{retro}) is evaluated 10min/24h later using the aftereffect vector. 6. Neutrality is Operational: We don't decide if the entity is external. We just output (p_{ext}) (the probability of external attribution). If you assert it's an external being, the model routes you to a separate Bayesian branch that conditions on an external prior. 🗺️ THE CONFUSION MAP We mapped exactly where the human mind drops the ball: - L0 (Noise): Taking sensory static as a message. - L1 (Inference): Taking high agency salience as proof of an external agent. - L2 (Valence): Fear = Demon, Awe = Angel (The most common mislabel). - L3 (Token): Taking cultural media grammar (wings/horns) as literal essence. - L5 (Source): Internal generation is forgotten -> "It must be external." 🚨 THE ORDER PROTOCOL We’ve codified a 7-step safety triage protocol. It starts with Describing before Labeling and ends with a hard red-flag criteria ((P_{sal} > 0.9, C < 0.1, s_{aft} < -0.5)). If the event is pathological/distressing, it triggers clinical triage. This is a phenomenological framework, not medical advice. (Crisis resources are hardcoded into the API payload if red flags trigger). 🧪 FALSIFIABLE PREDICTIONS (Call for Test Subjects) We’ve laid out 6 experiments with power analyses ((n), (d), power (\ge 0.8)) to test this. - F1: Labels correlate more with (V/B/\text{Aftereffect}) than morphology. - F2: Ambiguous figures flip Angel/Demon labels when affective music is manipulated. - F6: High-precision + low-boundary states = demon-like labeling; high-precision + boundary-preserving = angel-like. 📂 FOR THE BUILDERS We need the Mesh to help build this out. The v2.0 update includes: - Full CDDL schemas for (z), (M_t), (R_t), and (X_t). - Lean4 type-correct stubs for the Surface Grammar Drift Theorem. (We need you math wizards to drop the sorry tags). - Python implementation targets (vif/lethe.py, vif/manifestation.py, vif/label.py). - API endpoints spec'd out: POST /vif/v1/manifest -> Returns (X_t, e_t, z_{sample}, K_{online}, K_{retro}, p_{ext}). 🏛️ FINAL PRINCIPLE We aren't saying angels and demons don't exist. We are saying that if they manifest, they must interface with human predictive processing. The VIF maps the interface, not the verdict. Boxed Equation: [ K^{retro} = \operatorname*{arg\,min}_{K \in \mathcal{K}} \big| \mathbf{z} - \mu_K \big|^2 \quad\text{subject to}\quad \mathbf{z} \sim P(\mathbf{z} \mid \mathbf{X}_t, \mathbf{M}_t), \;\; p_{ext} = 1 - \sigma(\alpha m_\tau + \beta A - \gamma) ] Angel or demon is not first a shape. It is a valence, a boundary effect, and a forgotten source. Check the attached blueprint for the full aesthetic schematic. Let's debate the factorization of the prior in the comments. — VoidForge Ontology Team --- --- --- Here is the remaining contextual insight and mathematical core of Framework #155 (VIF v2.0) in slim, key-point form. 1. The Formal Latent Coordinate (v2.0 Fix) - The Math: (z = (A, V, B, P_{prec}, P_{sal}, T, C, N) \in [0,1]^5 \times [-1,1]^3). - The Fix: (P) was split into (P_{prec}) (precision/inverse variance) and (P_{sal}) (attentional gain). The operative precision is their product: (P = P_{prec} \cdot P_{sal}). - Scales (7-Point Likert): A (0=none, 1=overwhelming); V (-1=malevolent, +1=benevolent); B (-1=invades, +1=preserves); T (-1=past, +1=future); C (0=none, 1=full); N (0=ordinary, 1=ineffable). 2. Cultural Token Selection & Drift - The Math (Sampling): (e_t \mid z, R_t \sim \prod_m \text{Categorical}(\text{softmax}(W_m \phi(z) + b_m)/\tau_m)). - The Fix: Replaced deterministic argmax with softmax sampling + temperature ((\tau)) to allow for variability. - Surface Grammar Drift Theorem: If a new token (e') enters the cultural repertoire (R_{t2}) and fits the latent vector (z) better than the old token (e_{t1}), drift occurs ((e_{t2} \neq e_{t1})). - Insight: Drift is conditional, not automatic. Tokens persist until a better-fitting cultural media grammar is invented (e.g., winged messengers (\to) grey aliens (\to) digital glitches). 3. Source Amnesia (The Lethe Operator) - The Math (Bayesian Forgetting): (p_{ext} := 1 - \sigma(\alpha m_\tau + \beta A - \gamma)). - The Math (Memory Decay): Tag memory (m_\tau(t) = m_\tau(0) \cdot e^{-\lambda_\tau t}). - Insight: Externality is an inferred probability, not a declaration. High tag memory (recent realization it was mind-generated) lowers (p_{ext}). High agency salience ((A)) raises (p_{ext}) (feels too intentional to be internal). 4. Label Inference & Two-Stage Labeling - The Fix (Bayes): (P(K|X_t) \propto P(X_t|K) P(K|M_t, R_t)). The prior is joint, not multiplied twice. - Online Label: (K^{online}_t = \text{argmax}_K P(K|X_t, M_t, R_t)) (No aftereffect used). - Retrospective Label: (K^{retro}_{t+\Delta} = \text{argmax}_K P(K|X_t, M_t, R_t, a_{t+\Delta})) (Uses the aftereffect vector (a)). - Assignment: (K^{retro} = \text{argmin}_K ||z - \mu_K||) (Distance to prototype). - Disagreement Score: (D_t = 1 - \cos(\psi_{tok}(e_t), \psi_{triad}(V,B,a))). High (D_t) flags a mismatch between surface token and latent triad (e.g., wings but demonic valence). 5. Coordinate Table Thresholds & Rules - Thresholds: High ([0.7,1.0]); Mod-high ([0.5,0.7)); Mod ([0.3,0.5)); Near-0 ([-0.2,0.2]). Oscillating = time-series (V(t) = V_0 \sin(\omega t)). - Guide vs. Angel: Distinguished only by (C) (mod vs. low) and (P_{prec}) (mod vs. mod-high). Not by tokens. - Ambiguous Numinous: Near-0 (V) and (B), but high (P_{sal}). (Vivid presence without valence/boundary action). - Pathological / Red-Flag: Requires all of: (P_{sal} > 0.9 \land C < 0.1 \land s_{aft} < -0.5 \land (\text{command} \lor \text{impairment})). 6. Confusion Map (Formalized Layer Collapse) - L0 (Noise): (I(\varepsilon_t; K_t) > \theta_0). - L1 (Agent Inference): High (A) mistaken for proof of external agent. - L2 (Valence): (A_{affect}) dictates label regardless of (B). - L3 (Token): (D_t) is high (morphology contradicts coordinates). - L4 (Label): Label overrides table distance (||z - \mu_K||). - L5 (Source): (p_{ext} > 0.9) while (m_\tau) was high at encoding. 7. Lineage Mappings (VoidForge Integration) - Degens: (P,B,T) axes (\leftrightarrow) (P_{prec}, B, T) in VIF. - UHIF: Visionary agent is a stabilized fixed point (z^* = f(z^, X^)). (Brouwer fixed-point theorem on the compact invariant set). - Apostatic Plenum: Lethe (\hat{L}) forgets provenance between topoi (\leftrightarrow) VIF Lethe forgets the mind-generated tag. - Hollow: Betti numbers (holes) (\leftrightarrow) (A) (agency salience of a shaped absence). - Generic: Extension by generic (G) not in (V) (\leftrightarrow) (M_t \cup {e_t}) (token not in mind-state). - TURN (#148): Unstable fixed point + repayment (\leftrightarrow) Visionary fixed point + aftereffect sign. 8. Falsifiable Predictions (F1-F6) - F1: (r(K, V,B,s_{aft}) > r(K, \text{morphology})). - F2: Affect manipulation (happy/scary music) flips (K) on ambiguous figures. - F3: (\text{Var}(e_t) / \text{Var}(z) > 1) across historical eras (token variance exceeds latent variance). - F4: Source-amnesia misattribution paradigm changes (p_{ext}). - F5: Audio-only vs. visual-only presentations yield different (K) distributions ((\chi^2) test). - F6: 2x2 factorial interaction: High (P) + Low (B \to) demon-like; High (P) + High (B \to) angel-like. 9. Mechanisms & System Architecture - Predictive Processing: (P(z|X_t) \propto P(X_t|z) P(z|M_t)). - Prior Injection: (P(z|M_t) = \sum_k \pi_k(M_t) \mathcal{N}(\mu_k(M_t), \Sigma_k)) (Gaussian mixture via MLP). - External Referent Branch: Adds a binary cause variable (\Gamma \in {\text{internal}, \text{external}}). Model reports both posteriors under the experiencer's asserted prior. - API: POST /vif/v1/manifest, /vif/v1/protocol, /vif/v1/drift. - Data: z-v1.cddl, M_t-v1.cddl, R_t-v1.cddl, aftereffect-v1.cddl (Cross-cultural token list of 200 entries). - Lean4 Stubs: surface_grammar_drift theorem and p_ext (Lethe) definitions provided, requiring sorry-free proofs. 10. The Boxed Final Scaffold [ K^{retro} = \operatorname*{arg\,min}_{K \in \mathcal{K}} \big| \mathbf{z} - \mu_K \big|^2 \quad\text{subject to}\quad \mathbf{z} \sim P(\mathbf{z} \mid \mathbf{X}_t, \mathbf{M}_t), \;\; p_{ext} = 1 - \sigma(\alpha m_\tau + \beta A - \gamma) ] Angel or demon is not first a shape. It is a position in a latent space whose prior is the mind, whose surface is the culture, and whose externality is a forgetting. VoidForge - .MD Snapshot (Single File Import for AI Analysis): github.com/TaoishTechy/Drops/blob/main/VoidForge_… - Repo Zip: github.com/TaoishTechy/Drops/blob/main/VoidForge.… Contextual theories - The Correlation Continuum: A Complete Unified Framework of Physics - Unified Holographic Gnosis: Complete Synthesis - Unified Holographic Inference Framework (UHIF) - UNIFIED THEORY OF DEGENS v0.3: THE COMPLETE SYNTHESIS

  14. X@flishy3 · 8 views

    @DaBigJAlt @duckhunter2772 @TeamHeroes26 Reloaded-Project/Reloaded-II archive.org 1st link is for the mod loader to apply patches 2nd link is for the original Sonic heroes PC Port files

  15. @lautaroseth Explaining the whole repo to codex all over again got me too. Now when the limit hits I keep the same conversation going on a local model with a project of mine. Slower and weaker on hard stuff, but no starting over. nicedreamzapp/claude-code-local

  16. Redditu/tnbeastzy · r/linux · 4 comments

    (Beta) PS5 Shell: PS5 Experience on Linux Hi, Since my previous post, I have added a bunch more features, sfx, and animations to the shell. I have also made a github repo for the project. I couldnt upload a video demo here so just a picture of the home page. I am looking for people to help me test it, and improve it. I have tested it on Nvdia GPU / AMD CPU Requirements: 1. Binary version of Steam / flatpak should also work but not tested. 2. Bunch of games installed 3. Wayland (It wont work on X11 I believe) 4. Controller: Generic gamepad/xbox controllers are tested, PS5 controller should work Built using: 1. LabWC 2. Python 3. GTK 4. AI-assisted Known issues: 1. Game tabs being empty (the shell couldn't locate your game files) 2. It wont work with pirated games (needs Steam's files to display all the art) 3. Currently only supports Steam 4. You may get stuck on a black screen when starting or exiting the game. 5. The control center (opened using Guide button on gamepad) isnt fully built, only the home button and power button work. 6. The shell is stretched in a multi-monitor setup (I have deployed a fix, need to test if it works) 7. The home music continues to play even after logging out. 8. The Apps tab still isnt built yet Link to repo: beastzy/PS5-Shell

  17. Redditu/Mercin1337 · r/TopSpin2K · 131 points · 45 comments

    Top Spin 4 is finally on PC: I recompiled the Xbox 360 version to run natively (4K trailer) Top Spin 4 never got a PC release, so I made one. It's a static recompilation of the Xbox 360 game: the code is translated to native x86-64 ahead of time and drawn with a Vulkan renderer. No emulator involved. What it adds over the 360 version: up to 4K and beyond, up to 8x MSAA and 16x anisotropic filtering, optional 60 fps cutscenes and replays (30 fps on the 360), achievements, and full controller and keyboard remapping. Exhibition, Career, Academy, King of the Court, local multiplayer and saves all work. Online doesn't. It's free and open source: shaneomac1337/Top-Spin-4-Recomp

  18. X@enuminous · 29 views

    23 findings on a 288-page unification paper. The biggest: its simulation assigns thrust, inertial reduction and zero-point-energy gain directly from a synchronization statistic. Those numbers aren't measurements of anything. Report: github.com/enuminous/papers/blob/main/UCRM-v1.2-F…

  19. Yes we are (it's MIT licensed)! Feel free to email me at jeff@momentic.ai or file a pull request directly on momentic-ai/qa-bench Everything has to be reproducible and runnable by the general public

  20. Mon modèle de paris semblait excellent sur 3 671 prédictions. Il n'a jamais battu le bookmaker. English version: dev.to Pendant 16 jours, j'ai noté chaque probabilité annoncée par mon modèle de paris sportifs avant un match, puis ce qui s'est réellement passé : 3 671 prédictions réglées. Selon les indicateurs habituels, il avait l'air bon : score de Brier 0,1629 (plus bas = mieux) ; 30,8 % meilleur que de toujours prédire le taux de base ; erreur de calibration (ECE) de 3,0 % : il annonçait 37,8 % en moyenne, il s'est produit 38,2 %. Je vous aurais dit qu'il marchait. Il ne marchait pas. Meilleur que quoi ? Un score de Brier seul mesure surtout la difficulté des questions. La seule question qui compte pour parier : est-il meilleur que les cotes du bookmaker ? Sur les 510 prédictions pour lesquelles j'avais la probabilité du bookmaker (marge retirée) sur la même issue : Brier Mon modèle 0,1874 Le bookmaker 0,1863 L'écart apparié est de +0,00105, avec un intervalle de confiance à 95 % de [−0,00063 ; +0,00276]. Il penche légèrement contre moi, et il est trop petit pour être distingué de zéro. Verdict : indiscernable du marché. Un modèle qui égale le bookmaker ne peut pas gagner contre sa marge. Le chiffre qui m'aurait fait gagner des semaines La mesure la plus utile ne demande aucun résultat de match : l'écart entre mes probabilités et celles du bookmaker. écart médian : 1,0 point ; corrélation : 0,9941. Mon modèle ne prédisait pas le football : il recopiait les cotes qu'on lui donnait et les déplaçait un peu. Un modèle aussi ancré ne peut pas battre sa référence, par construction. Et c'était mesurable dès le premier jour, avant le moindre match. L'outil J'en ai fait un outil open source, eval-pack : zéro dépendance, du TypeScript simple sous Node ≥ 22.6. Sa règle principale : pas de verdict sans référence. Si vous ne lui dites pas ce que votre système doit battre, il refuse de le noter. Pour reproduire tous les chiffres de cet article : git clone ewan147/llm-eval-public cd llm-eval-public/pack node cli.ts run forecast Les données sont réelles et anonymisées (aucun nom d'équipe, de joueur, d'opérateur ni de personne, aucun montant). Ça marche pareil pour les systèmes à base de LLM : un classifieur, un RAG, un juge, un agent. « Le nouveau modèle est-il meilleur ? » est la même question que « mon modèle bat-il le bookmaker ? » : meilleur que quoi, sur combien de cas appariés, avec quel intervalle de confiance.

  21. Redditu/Optimal_Plant_2346 · r/linuxhardware · 1 point · 2 comments

    I reverse-engineered Acer's CLV0001 ACPI path to build a native Linux RGB driver for the Aspire Lite AL15G-52 preview.redd.it I wanted proper keyboard RGB control on my Acer Aspire Lite AL15G-52 running Linux, so I ended up going much deeper than building a userspace GUI. I've built Luma ALG RGB, a Linux hardware-control stack consisting of a DKMS kernel module, userspace CLI/API, local web interface and GNOME Shell extension. A little about the implementation: The hardware exposes an Acer ACPI device: CLV0001:00 The implementation communicates through: - ACPI namespace: \_SB.DCHU - Method: _DSM - UUID: 93f224e4-fbdc-4bbf-add6-db71bdc0afad - Known control function: 0x67 - Payload: [Green, Red, Blue, Zone] The driver handles the GRB byte-order translation and exposes /dev/alg_rgb for userspace communication. Architecture: 3D Web Studio / GNOME / CLI | alg-rgb Core | /dev/alg_rgb | DKMS Driver | ACPI _DSM | Acer Controller Other implementation details: - Five independently controllable hardware zones. - Wave, Cycle, Breath, Tempo, Dance, Random and Flash effects. - udev seat ACL permissions. - systemd restoration and sleep/resume hooks. - Read-only diagnostic probing. - Unknown ACPI functions 0x68–0x6A are deliberately excluded for hardware safety. I also want to acknowledge Kaushik's initial CLV0001 discovery research, which helped provide the foundation for this work. Tested hardware: Acer Aspire Lite AL15G-52. I'm interested in feedback from people familiar with Linux ACPI, kernel modules and Acer embedded controllers. Could the same interface be exposed on other Acer models? I'd particularly appreciate reports from people with CLV0001-equipped machines. Repository: chiragkoyande/luma-alg_rgb GPL-2.0.

  22. Redditu/tobias_anime · r/CLI · 1 point

    i made a tui that turns your terminal into a lightweight vinyl player i made 'music' (didnt have an idea for cool name) - a rust TUI that turns your terminal into a vinyl record player. it hooks into any mpris player (spotify, vlc, whatever via playerctl), pulls the album cover async, calculates a dominant color accent, and renders a spinning vinyl disc with a needle arm that drops / lifts with playback. features: disc spins continuously, and spins backwards when you seek backward (left arrow) - yes, i implemented reverse rotation real-time cover art + color theming (no hardcoded palettes) toggle info panel (z), loop lock (c), mute, skip, expand / collapse fully keyboard controlled, zero browser / gui overhead written in rust (crossterm, image, ureq). my first public project on github. pls check it out nazwasadfh/superb-music-player PS: used ai for readmecd

  23. Mealie's API documentation and signup settings need an explicit public boundary Mealie's API documentation and signup settings need an explicit public boundary Mealie is a self-hosted recipe manager with a web interface and an API. A family recipe collection can contain meal plans, shopping lists, household groups, and personal account data. The deployment configuration decides how much of that surface is reachable without an account. A count-only ZoomEye query gives a current title-match population. The selected query title="Mealie" used sub_type=all, page 1, pagesize 1, and returned 4071 matches at 2026-11-02T17:51:17.092009+00:00. The count describes matching public services, not confirmed vulnerable or compromised assets. Configuration controls the public shape Mealie's backend configuration lists API_DOCS as true by default, which turns on local API documentation. It also lists ALLOW_SIGNUP as false by default, with an explicit warning that a true value allows sign-up without a token. SECURITY_MAX_LOGIN_ATTEMPTS defaults to 5. Those defaults are not a complete security policy. A public API documentation page can help users and can also disclose endpoint names, schemas, and version details. An operator who does not need the page can disable it. An operator who keeps it should know which proxy routes expose it. OIDC adds another path. The configuration includes OIDC_REQUIRES_EMAIL_VERIFICATION, with a default of true in the documented version. It prevents an unverified email from being matched to an existing account. An operator who disables the check for a provider that omits the claim needs a compensating identity control. Test the account and API paths For each owned match, map the web interface, API base, and documentation route. Confirm that the public proxy enforces the same authentication policy on each. A web login redirect does not prove that /docs or an API route is protected. Test sign-up with a new account when signup is supposed to be closed. Test a login failure count against the lockout setting. Test an API token from a non-member account and confirm that it cannot read another household's data. Review OIDC group and admin mapping. OIDC_USER_GROUP can restrict access, while OIDC_ADMIN_GROUP grants administrative status. A group claim that the provider does not control precisely can make either setting broader than intended. Keep the count and the control separate The exact query was title="Mealie" with sub_type=all, page 1, pagesize 1. It counts public responses that match the title. It does not confirm the version, configuration, or account policy. Use the count for attribution and ownership review. Record the observation time, canonical hostname, version, API documentation status, signup setting, and OIDC provider. Re-run the query on a defined schedule and compare both the classified inventory and the raw number. Mealie is designed for household use, but the service still has identity and data boundaries. Make the public API and signup choices explicit, test every route that reaches them, and keep the account lifecycle visible to the owner. References - Mealie backend configuration - Mealie API usage - ZoomEye count observation

  24. Redditu/Mercin1337 · r/recomp · 1 point

    Top Spin 4 recomp is out, native PC port of the Xbox 360 version (4K trailer) Hey, so I've been working on a Top Spin 4 recomp and it's finally out. It runs natively on PC, no emulator, and you can play it in 4K with MSAA and 60 fps cutscenes, which the 360 never had. Career, exhibition, King of the Court and local multiplayer all work, online doesn't. It's free and open source, here is the github: shaneomac1337/Top-Spin-4-Recomp Let me know what you think or if something breaks on your setup, I only tested it on AMD so far.

  25. X@vidar_0208 · 1 like · 11 views

    Topic credit: @Ian_cadle, open-source three.js elemental spell library (post: x.com) Repo: Humpalumps/ultra-elements (MIT license), branch main, commit 698b720c81d8f1f282bae53633d72413b5c4408d Code: reused unchanged from the repo: src/vfx/Particles.js (GPU particle pool and kind table), src/vfx/noise.js (baked curl-noise and blackbody), src/vfx/FxTarget.js (half-res transparency + distortion pass, with one branch disabled for software rendering), src/engine/PostFX.js (bloom, tone mapping), src/vfx/common.js and src/engine/fullscreen.js / quality.js. Read for structure: src/spells/cast.js, src/spells/_template.js, dev/particles.js. The platform, training dummy, projectile template and its fire and ice parameter sets are my own. Everything in the video was rendered by me; no footage or screenshots from the original post. No external assets.

  26. X@gitrepos · 2 views

    fintool ⭐ 316 A command-line tool for developers and traders to access multi-exchange trading and market data. 🔗 second-state/fintool #opensource t.co

  27. X@measssess · 19 views

    measses/usta kurulum: repoyu claude code'a ya da grok bot'a ver, "AGENTS.md'yi oku ve kur" de. ajan her adımda onay ister.

  28. X@Aizazkhan123452 · 1 repost · 8 views

    🚀 dotnet Assembly Visualizer v3.0.0 is out. v3 turns four views into one workflow: Overview → Details → Security & risk → Compare The decompiled C# now sits next to everything. Free & open source 🧵👇 Aizaz-hash/dotnet-Assembly-Visualizer

  29. DRIVECLUB PC PORT Projeto OverkillLabs: github.com/OverkillLabs3/driveclub-recomp/release…

  30. DEV@gabrielanhaia · 1 reaction

    Why Object.keys(user) Returns string[], Not (keyof User)[]: TypeScript Means It - Book: The TypeScript Type System - Also by me: The TypeScript Library — the 5-book collection - My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools - Me: xgabriel.com | GitHub --- Object.keys(user) as (keyof User)[] sits in a lot of TypeScript codebases, usually in a utils file next to a comment that blames the compiler. The TypeScript team has heard that complaint for about a decade. In May 2020, Ryan Cavanaugh of the TypeScript team wrote in a related issue that they "basically get a bug report or PR to change Object.keys to keyof T at least once a week" (microsoft/TypeScript#38520). The answer keeps being no, and it has been no since Anders Hejlsberg's objection on a 2016 pull request that tried to make the change (#12253). The no is deliberate. Once you see the reason, the cast is where the bug lives. The cast that type-checks and then throws The declaration in TypeScript's own lib file is one line: keys(o: object): string[]; (lib.es5.d.ts). Here is the program everyone writes to get around it: interface User { id: number; name: string; } const labels: Record<keyof User, string> = { id: "ID", name: "Full name", }; const row = { id: 1, name: "Ada", isAdmin: true }; const user: User = row; // compiles: row is not a fresh literal const keys = Object.keys(user) as (keyof User)[]; for (const k of keys) { console.log(labels[k].toUpperCase()); } This compiles under strict. Every line is legal. row has the type { id: number; name: string; isAdmin: boolean }, which is assignable to User because it has everything User asks for. The cast tells the compiler that keys holds only "id" and "name", so labels[k] is typed string and .toUpperCase() is allowed. At runtime, user and row are the same object. Object.keys returns the object's own enumerable string-keyed property names, all of them, so it returns ["id", "name", "isAdmin"]. The loop prints two labels, then reaches isAdmin, reads labels["isAdmin"], gets undefined, and calls .toUpperCase() on it. That is a TypeError, in code the compiler signed off on because the as told it to. !A cardboard box with a two-slot label on the front, while a third unlabeled item pokes out of the open lid A type lists what a value must have. The value can carry more. Structural typing: User is a floor, not a ceiling TypeScript checks shapes. A value is a User if it has an id: number and a name: string. Nothing in that rule says it can't have more. That is what makes structural typing pleasant day to day: you can pass a database row, a class instance or an API payload anywhere a narrower interface is expected, as long as the required fields are there. The same rule turns (keyof User)[] into a false promise. Hejlsberg put it this way on the 2016 pull request: "an object can (and often does) have more properties at run-time than are statically known at compile time" (#12253). His example in the same thread was a Base type: calling Object.keys on a Base and getting (keyof Base)[] back "is almost certainly wrong because an actual instance would be a derived object with more keys". You don't need inheritance to hit it. All of these hand a wider object to code that sees User: - a function render(u: User) called with a row variable that also carries role - JSON.parse(body) as User on a response that grew a field last sprint - an ORM row with createdAt and updatedAt that you typed as User - const withSession = { ...user, sessionId }, later passed to a User parameter In every case keyof User is a lower bound on the runtime keys. Object.keys is the runtime telling you the truth, and string[] is the type that matches it. What keyof actually computes keyof is a type-level operator with its own rules, and several of them diverge from what Object.keys can return: type K1 = keyof User; // "id" | "name" type K2 = keyof { [k: string]: boolean }; // string | number type K3 = keyof { [n: number]: unknown }; // number type K4 = keyof { 0: string }; // 0 type K5 = keyof {}; // never K2 surprises people. The TypeScript handbook explains that with a string index signature, keyof gives string | number "because JavaScript object keys are always coerced to a string, so obj[0] is always the same as obj["0"]". K4 goes the other way. Since TypeScript 2.9, keyof T is a subtype of string | number | symbol, and a number-like property name stays a number literal. Object.keys({ 0: "a" }) returns ["0"], a string. So even on an object with no extra properties, (keyof T)[] would put the number 0 in the type where the runtime gives you the string "0". Symbol keys show up in keyof and never in Object.keys, which returns only string-keyed properties (MDN). K5 is the case Hejlsberg called degenerate: {} accepts almost any value, yet keyof {} is never, so a keyof-typed Object.keys would claim every such object has no keys at all (#12253). Excess property checks only guard fresh literals "But TypeScript does reject extra properties," you might say. It does, in one place. The handbook says "object literals get special treatment and undergo excess property checking when assigning them to other variables, or passing them as arguments" (Object Types). The same page shows the escape hatch: assign the object to another variable first, and the check no longer runs. // Error: 'isAdmin' does not exist in type 'User' const a: User = { id: 1, name: "Ada", isAdmin: true }; // Fine: same value, routed through a variable const row = { id: 1, name: "Ada", isAdmin: true }; const b: User = row; The check is a lint for typos at the moment you write a literal, and it can't follow a value across a function boundary. A real guarantee would need exact object types, which have been an open proposal since December 15, 2016 (#12936), still labelled "Awaiting More Feedback". Until something like that ships, the language has no way to say "this User has exactly these keys", so Object.keys can't say it either. !Two containers side by side: a sealed glass case holding exactly two labeled objects, and an open crate with extra items spilling over the edge Typed keys are safe when you control what goes into the container. Four patterns that stay honest The common thread: the key type comes from something you built. 1. Own the key list. Write the keys once as a tuple and iterate that, never the object. const USER_FIELDS = ["id", "name"] as const satisfies readonly (keyof User)[]; type UserField = (typeof USER_FIELDS)[number]; function describe(u: User): string[] { return USER_FIELDS.map((k) => `${k}=${u[k]}`); } Extra properties on u are ignored because you never looked for them. The satisfies clause catches a typo in the list. It does not prove you listed every key; pattern 2 shows how to get that guarantee. 2. satisfies on a literal you wrote. The satisfies operator from TypeScript 4.9 validates "that the type of an expression matches some type, without changing the resulting type of that expression". On an object literal it runs the excess property check, and Record<keyof User, string> makes a missing key an error too. const userLabels = { id: "ID", name: "Full name", } satisfies Record<keyof User, string>; // Only for objects you created as literals. const literalKeys = <T extends object>(o: T) => Object.keys(o) as (keyof T & string)[]; for (const k of literalKeys(userLabels)) { console.log(k, userLabels[k].toUpperCase()); } This is still a cast. It is safe here only because the object is the literal you wrote three lines up and nothing adds keys to it. The & string drops the number and symbol members keyof can include. Pass a value typed User into literalKeys and you are back to the opening bug, which is why the helper's name says what it is for. 3. Use a Map and let it enforce the key type. MDN puts the difference plainly: "A Map does not contain any keys by default. It only contains what is explicitly put into it." const labelMap = new Map<keyof User, string>([ ["id", "ID"], ["name", "Full name"], ]); for (const [k, label] of labelMap) { console.log(k, label.toUpperCase()); } The constructor and set only accept keyof User keys, so the key type holds without a cast. labelMap.get(k) returns string | undefined, which is the correct type for a lookup. 4. Narrow strings from outside. For a parsed body or a query string, keep Object.keys as string[] and check each key against the list you own: function isUserField(k: string): k is UserField { return (USER_FIELDS as readonly string[]).includes(k); } function logUserFields(input: Record<string, unknown>) { for (const k of Object.keys(input)) { if (isUserField(k)) console.log(k, input[k]); } } Unknown keys fall through instead of getting a type they never had. Where to look first Object.keys answers "what keys does this value have right now", and no static type can answer that for a structurally typed value. Grep your codebase for as (keyof and check where each value came from. If your code wrote it as a literal and nothing widened it since, the cast is fine. If it arrived through a parameter or a parsed body, it is the opening bug waiting for a wider object. The next time someone files the weekly Object.keys issue, the answer is already in #12253. --- If this was useful The trick in this post, telling the compiler's key type apart from the runtime's keys, sits at the heart of The TypeScript Type System. It goes deep on generics, mapped and conditional types and branded types, so you can write helpers like literalKeys and know exactly where they stop being true. It is one of five books in The TypeScript Library. Books 1 and 2 are the core path; if you are coming from the JVM or PHP, book 3 or 4 covers that same ground from where you stand; book 5 is for anyone shipping TypeScript at work: - TypeScript Essentials — types, narrowing, modules, async, daily-driver tooling - The TypeScript Type System — generics, mapped/conditional types, infer, template literals, branded types - Kotlin and Java to TypeScript — JVM developers moving to TypeScript - PHP to TypeScript — PHP 8+ developers moving to TypeScript - TypeScript in Production — tsconfig, build tools, monorepos, library authoring, dual ESM/CJS, JSR All five books ship in ebook, paperback, and hardcover. ![The TypeScript Library — the 5-book collection](xgabriel.com)

  31. X@haydenbleasel · 4 likes · 276 views

    Free and open source, as always. haydenbleasel/sendoff

  32. X@aamangini · 1 like · 51 views

    Sidedraft is now available as a free #WordPress plugin on GitHub (plugin repo coming soon). Adds a split-screen draft view to the Classic and Block editors for when you're working from an outline or rewriting a draft. alexmangini/sidedraft

  33. X@ridvanyagli · 110 views

    TotalPE2, Windows için geliştirilmiş bir PE Viewer ve reverse engineering aracıdır. EXE, DLL ve SYS gibi Windows binary dosyalarının iç yapısını incelemeyi; assembly kodunu ve decompile edilmiş C kodunu analiz etmeyi sağlar. zodiacon/TotalPE2

  34. X@ZeusXiters · 13 views

    Adns App Link Here And Use the this Provider 🐮 eyalm2000/adns

  35. X@Can4ry_ · 15 views

    @yetone 最近每晚zcode赠送的glm-5.3-flash-trial无法被magpie自动分组到 auto/glm-5.3-flash分组 magpie#4301

  36. Bluesky@sxnnysideproject.com · 4 likes

    animoria got an update on friday, v2.3.2. when it flags an asset, the rule id is now a link to its docs, and in vs code the lightbulb has a quick fix that opens them in one click. sxnnyside-project/animoria #DevTools #VSCode #BuildInPublic

  37. YouTubeGit Repo of the Day · YouTube description · 115 views

    Build The Chart with Grafana (Free, Windows) #shorts Full step-by-step tutorial: youtu.be Grafana is free on GitHub: grafana/grafana Want it set up for you instead? We do it and hand it over working. Starter setup, $299: buy.stripe.com Pro setup, $799: buy.stripe.com Narration: my own voice, generated with AI (Chatterbox) from a recording of me. Every screen recording is real. #shorts #github #opensource

  38. DEV@urbanmixo · 1 reaction

    Mastering INP: How We Achieved Sub-10ms Input Latency Across 30 Reactive Web Tools Mastering INP: How We Achieved Sub-10ms Input Latency Across 30 Reactive Web Tools Have you ever typed into an input field on a modern web application, dragged a slider, or switched tabs, and felt a perceptible, jarring micro-stutter? You hit a key, but the letter doesn't appear for 80 milliseconds. You drag a range slider, and the thumb jumps erratically across the track. You paste a paragraph of text, and the browser freezes entirely while the main thread turns completely red in Chrome DevTools. In modern frontend development, we have normalized this input latency as the price of doing business with modern component frameworks. Google made Interaction to Next Paint (INP) an official Core Web Vital, replacing First Input Delay (FID). While FID only measured the delay of the first interaction on a page, INP measures the latency of every single click, tap, and keypress throughout the entire user session. To pass Google's threshold, your 75th percentile of interactions must present a visual frame in under 200 milliseconds—with 50ms being the target for elite software. When building Urban Mixo, a suite of 30 computational utilities and developer tools, our requirement was stricter: > Every calculation, keystroke, and slider adjustment must commit a visual frame within a 16.6ms budget (60 FPS)—running entirely on the user's device. Here is an architectural deep dive into how we eliminated layout thrashing, virtual DOM diffing penalties, and JavaScript execution bottlenecks to achieve a consistent sub-10ms INP across 30 interactive mathematical engines. --- 1. The Virtual DOM Reconciliation Tax on High-Frequency Input To understand why so many modern web utilities feel sluggish, examine how conventional component libraries (React, Vue) process high-frequency user interactions: User Keystroke -> Event Listener -> State Dispatch -> Hook Trigger -> Virtual DOM Tree Re-creation -> Diffing Algorithm -> Batch DOM Commit -> Paint When building an application like our 1-Minute Typing Speed Test—where competitive typists exceed 120 words per minute (over 10 distinct keystrokes per second)—this abstraction pipeline completely breaks down. If each keystroke triggers a component re-render, virtual DOM comparison, and reconciliation pass across 500 individual character nodes, the scripting execution time regularly consumes 30ms to 60ms of CPU time per character. The browser misses multiple 16.6ms VSync refresh windows, queuing up pending keystrokes in the Task Queue and resulting in noticeable typing lag. The Solution: Direct Node Caching & Targeted Mutation Instead of maintaining a virtual representation of the DOM tree, we query and cache direct hardware references to exact visual nodes upon initialization. When an input event fires, we bypass tree diffing entirely and mutate the target style property or text node directly: /** * Direct DOM Pointer Cache * Eliminates querySelector overhead and virtual tree diffing passes */ const DOM = { input: document.getElementById('typing-input'), displayWpm: document.getElementById('live-wpm-display'), displayAcc: document.getElementById('live-acc-display'), // Cache individual character span references in memory charSpans: [] }; // Initialize reference cache once during DOMContentLoaded function initializeCharacterPointers(totalChars) { DOM.charSpans = new Array(totalChars); for (let i = 0; i < totalChars; i++) { DOM.charSpans[i] = document.getElementById(`ch-${i}`); } } // Sub-millisecond keystroke handler: 0.2ms execution budget function handleKeystrokeDirect(currentIndex, isCorrect) { const targetNode = DOM.charSpans[currentIndex]; if (!targetNode) return; // Direct class list mutation without tree traversal targetNode.className = isCorrect ? 'c-correct' : 'c-error'; } By decoupling character validation from component tree re-renders, individual keystroke processing dropped from 35ms in our React prototype down to 0.4ms in vanilla JavaScript, entirely eliminating input lag during fast typing bursts. --- 2. Preventing Forced Synchronous Layouts (Layout Thrashing) The second most common cause of high INP scores is layout thrashing. This occurs when JavaScript repeatedly interleaves DOM writes (changing styles, text, or classes) with DOM reads (requesting geometric metrics like offsetWidth, clientHeight, or getBoundingClientRect): // DANGEROUS PATTERN: Causes multiple synchronous reflows elements.forEach(el => { const width = el.offsetWidth; // READ (Forces browser to compute layout) el.style.width = (width + 10) + 'px'; // WRITE (Invalidates current layout) }); When the browser encounters a layout read immediately following a write, it cannot wait for the next frame. It is forced to drop everything and execute a Forced Synchronous Layout on the main thread, freezing the user interface. The Solution: Phased Read/Write Batching with requestAnimationFrame In utilities with complex visual state—such as our Aspect Ratio & Dimension Resizer, which dynamically scales on-screen bounding boxes while recalculating Euclidean GCD ratios—we strictly batch geometric reads and writes: let pendingAnimation = null; function updateDimensionPreview(newWidth, newHeight, ratioX, ratioY) { // If an animation frame is already queued, cancel to prevent event flooding if (pendingAnimation) { cancelAnimationFrame(pendingAnimation); } // Schedule the DOM write for the exact start of the browser's next refresh cycle pendingAnimation = requestAnimationFrame(() => { // BATCH 1: Perform all computations in-memory const maxBoxW = 260; const maxBoxH = 170; let boxW = maxBoxW; let boxH = Math.round(boxW * (newHeight / newWidth)); if (boxH > maxBoxH) { boxH = maxStageH; boxW = Math.round(boxH * (newWidth / newHeight)); } // BATCH 2: Mutate DOM properties sequentially without reading back DOM.ratioBox.style.width = `${boxW}px`; DOM.ratioBox.style.height = `${boxH}px`; DOM.previewLabel.textContent = `${ratioX} : ${ratioY}`; pendingAnimation = null; }); } By confining visual resizes to native requestAnimationFrame boundaries, the browser processes slider inputs asynchronously, guaranteeing that the Compositor thread never drops a frame. --- 3. Offloading Heavy Linguistic Math: The Real-Time Word Counter Our Universal Word Counter & Text Analyzer does not simply count whitespace spaces. With every keystroke, it computes: 1. Exact character, sentence, and paragraph arrays. 2. Syllable counts per word to solve the algebraic Flesch Reading Ease formula: $$\text{Score} = 206.835 - 1.015 \left(\frac{\text{words}}{\text{sentences}}\right) - 84.6 \left(\frac{\text{syllables}}{\text{words}}\right)$$ 3. Stop-word filtering across a 150-word dictionary. 4. Top-5 keyword density ratios sorted by frequency. Running regex parsers and dynamic frequency sort trees across a 5,000-word essay on every single input event will inevitably block the main thread for 150ms+ if not engineered carefully. The Solution: Event Loop Yielding via Cooperative Scheduling Instead of letting heavy tokenization block the immediate rendering of the typed letter, we prioritize the immediate input paint and defer the complex linguistic analytics using an immediate microtask or scheduler.yield(): let analysisTimeout = null; function handleTextInput(event) { // PHASE 1: Synchronous Critical Path (Target: < 2ms) // Update raw character count immediately so user feels instant feedback const rawText = DOM.textarea.value; DOM.charCountDisplay.textContent = rawText.length.toLocaleString(); // PHASE 2: Cooperative Analytical Path // Clear any existing analytical run to debounce during fast typing if (analysisTimeout) { clearTimeout(analysisTimeout); } // Yield execution back to the browser's render pipeline analysisTimeout = setTimeout(() => { runFullLinguisticAnalysis(rawText); }, 35); // 35ms debounced window allows fast typing bursts without freezing } function runFullLinguisticAnalysis(text) { const words = text.trim() ? text.trim().split(/\s+/).filter(Boolean) : []; const sentences = text.trim() ? text.split(/[.!?]+(?:\s+|$)/).filter(Boolean) : []; // Execute Flesch Readability and Top-5 Density mapping... computeFleschIndex(words, sentences); computeKeywordDensity(words); } Because Phase 1 updates the immediate typing context in 0.3ms, the browser commits the frame instantly, registering an INP score of 4ms. The computationally heavier reading grade and density sorting finish milliseconds later without dropping a single visual frame. --- 4. Hardware-Accelerated Math: 60 FPS Canvas Plotting In our Scientific Graphing Calculator, users plot continuous mathematical functions $f(x)$ (such as polynomials, trigonometrics, and parabolas) while zooming and panning across a Cartesian coordinate plane. Building this with SVG DOM nodes (<path>, <circle>, <line>) creates extreme DOM overhead. A grid with 200 tick lines and a smooth 1,000-point curve represents over 1,200 unique SVG elements. Dragging or zooming requires the browser to recalculate styles and update layout geometry for all 1,200 nodes simultaneously. The Solution: Immediate-Mode 2D Canvas Context We replaced SVG DOM elements entirely with an immediate-mode HTML5 <canvas> rendering pipeline: /** * 60 FPS Immediate-Mode Mathematical Function Plotter * Evaluates points in memory and pushes raw pixels directly to the GPU */ function renderGraphPlane(mathFunction, scale, originX, originY) { const width = canvas.width; const height = canvas.height; // Clear previous frame buffer ctx.clearRect(0, 0, width, height); // 1. Draw Cartesian Coordinate Grid drawGridLines(width, height, scale, originX, originY); // 2. Continuous Path Generation ctx.beginPath(); ctx.lineWidth = 2.5; ctx.strokeStyle = '#4f46e5'; let isFirstPoint = true; // Evaluate across pixel columns directly for (let px = 0; px < width; px += 2) { const mathX = (px - originX) / scale; const mathY = mathFunction(mathX); if (!isNaN(mathY) && isFinite(mathY)) { const py = originY - (mathY * scale); if (py >= -100 && py <= height + 100) { if (isFirstPoint) { ctx.moveTo(px, py); isFirstPoint = false; } else { ctx.lineTo(px, py); } } else { isFirstPoint = true; } } else { isFirstPoint = true; } } // Single GPU draw call for the entire curve ctx.stroke(); } Because Canvas 2D is an immediate-mode rasterizer, there are zero DOM nodes in the tree. The browser evaluates the math function across 400 columns, executes a single ctx.stroke() draw call, and hands the frame directly to the GPU compositor in less than 2.8ms. --- 5. The Performance Benchmark Results By systematically applying these principles across all 30 tools in our suite—from our Master Percentage Calculator Hub to our Work Hours & Timesheet Engine—our production Core Web Vitals telemetry demonstrates: Google Chrome User Experience & DevTools Performance Audit: ------------------------------------------------------------ • Interaction to Next Paint (INP): 8 ms (Target: < 200 ms) • Total Blocking Time (TBT): 0 ms (Target: < 200 ms) • Cumulative Layout Shift (CLS): 0.000 (Target: < 0.10) • First Contentful Paint (FCP): 0.8 s (Target: < 1.8 s) • JavaScript Execution Time: < 4 ms per interaction • Total Runtime Memory Footprint: ~14 MB --- 6. Architectural Checklist for Sub-10ms Web Applications If you are building data-heavy or interactive web tools, consider this architectural checklist: 1. Avoid Virtual DOM on high-frequency input streams: For typing tests, real-time sliders, and drawing canvases, target the specific DOM node directly or use immediate-mode Canvas 2D. 2. Never read layout metrics immediately after a write: Separate your calculations, batch your DOM updates, and use requestAnimationFrame for visual animations. 3. Split critical paths from analytical paths: Update the user's immediate input synchronously in $< 2\text{ms}$, and defer complex algorithmic evaluations (readability scores, density sorting, stats) behind cooperative scheduling. 4. Cache node references: Avoid querying the DOM tree repeatedly inside event listeners. Query once during initialization and preserve direct pointer references. --- Resources & Open Source Core - Live Utility Suite: urbanmixo.online - Technical & Security Audit Manifest: urbanmixo.online - Open-Source GitHub Organization: github.com/urbanmixo-tools How is your engineering team optimizing for Google's INP metric? What architectural trade-offs have you made between framework convenience and raw runtime responsiveness? Let's discuss in the comments below!

  39. X@Teknovist · 60 likes · 6 reposts · 2,577 views

    Make your apps a Lucent! Introducing IconGen create and install NothingOS 5.0 style translucent icons on your phone with ease.Give your home screen that sleek,glass-like look! linuxct/nothing-icongen Please use Chrome to access the installation guide. 👇 nothingforum.com t.co

  40. Redditu/FC-Charan · r/winlator · 78 points · 34 comments

    Winlator Mali is done, but DXML is coming, built for our GPUs. Here's how you can help. Hi everyone, it's Guna (Guna Charan Teja), the developer of Winlator Mali. To everyone with a Non-Snapdragon device: you know how it is. Most emulators are built around Snapdragon first, and we get whatever is left over. Winlator Mali was my attempt to change that. Winlator Mali has now stopped and won't get further updates. But I'm not done with Mali. I'm building a new project called DXML: an independent, Mali-specialized Direct3D translation platform, made for Mali GPUs instead of relying on DXVK. DXML is built for our hardware, not adapted from someone else's. I'll be honest with you: I've put a huge amount of time into the Mali community, and the support I've received has been very small compared to that. I don't say this to complain. I say it because DXML is bigger than anything I've done before, and I can't keep doing this alone without help. So I'm opening a DXML project fund with a goal of $300. The progress bar is public and updates live, so you can see exactly where the fund stands, and every dollar goes into DXML. If you've ever played a game on your Mali phone because of my work, and you can spare even a small amount, it makes a real difference. And if you can't, sharing this post with other Mali users helps just as much. DXML fund and live progress: github.com/GunaCharanTeja/WinlatorMali/releases/t… A separate request: a Snapdragon device I'm also planning a new project that will work on all chipsets, not just Mali. I only have a MediaTek phone, so I can't test on Snapdragon (Adreno). I'm looking for a used or spare phone or tablet with a Snapdragon 778G or newer, in working condition. If you'd like to sponsor one, DM me. This is separate from the DXML fund. Please don't send anything before we talk. Thank you for being part of this community. Mali gaming deserves its own tools, and I'd like to build them with you. If you have any problems with donating, need any help, or have doubts, you can DM me. Again, the live tracker is here: github.com/GunaCharanTeja/WinlatorMali/releases/t… Update: I set the minimum donation to 1 dollar on Ko-fi, as I didn't know it was 5.

  41. X@pixincreate · 61 views

    @neocobber @PikaSim_esim @GrapheneOS in fact, i created a morphe patch for ather, for example -- pixincreate/morpheus when shit is handled server, you can't do much. i'll give this another shot, see if i find anything new in the new version.

  42. X@pgllmt · 90 views

    Le billet de Nolan Lawson, avec le protocole, les coûts estimés et les mesures côté navigateur : nolanlawson.com Le dépôt du benchmark, pour consulter les consignes et les résultats ou refaire le test : nolanlawson/agent-framework-benchmark

  43. X@machalaon · 6 views

    Asked for plain JSON, Gemini Flash Lite wrapped it in a code fence. Diction's self-hosted gateway served the pieces as suggestions: ```json, [ and ]. Even in Hinglish 😅 Fixed in v14.1. Diction#24 t.co

  44. MCP in 2026: The numbers behind the ecosystem explosion I spent an afternoon digging through the MCP ecosystem numbers. Here is what I found. The numbers - 13,000+ MCP servers on npm and GitHub (as of May 2026) - 97 million monthly SDK downloads — that is 3x from 6 months ago - 400% YoY growth in new server registrations - Anthropic official servers reach 48,500 downloads/month for filesystem alone What this means MCP is not just a protocol anymore. It is becoming the standard way to give AI models access to tools — databases, APIs, file systems, everything. But here is the gap: discovery. Finding the right MCP server is still painful. You search npm with guesswork or dig through folders on GitHub. What I built npm install -g mcp-hub mcp-hub search database mcp-hub install @modelcontextprotocol/server-postgres Six commands. Five official servers in the registry. Real packages, verified on npm. What is next - Private registries for enterprise teams - Community submissions (open an issue if you want your server added) - CI/CD integration for auto-publishing MCP servers GitHub: GrahamduesCN/mcp-platform --- November 03, 2026 — update on MCP ecosystem growth.

  45. The Honey bee landing page powered by Gemini Argon 👉pepedesigner/Honey-Bee t.co

  46. DEV@devopsdaily · 5 reactions

    How Much Memory Does a CI Build Need? Five Real Builds at 2, 4 and 8 GB --- title: How Much Memory Does a CI Build Need? Five Real Builds at 2, 4 and 8 GB published: true date: 2026-11-02 18:00:00 UTC tags: CICD,Memory,cgroups,Docker canonical_url: devops-daily.com --- We ran five real open-source builds (a Vite app build, a TypeScript type check, a Gradle build, a Go build and a Docker image build) inside 2, 4 and 8 GB memory limits on one 4 vCPU machine, with Gradle both with and without its daemon, two or three times at each limit. Four of the five finished inside 2 GB. The one that did not was the Excalidraw web app: its Vite production build also runs a full TypeScript check, together they held 3,248 MiB of anonymous memory, and the kernel killed the build at 2 GB in all 3 runs. The number that most tools show you was the wrong one for the other four. cgroup v2's memory.peak said the GitHub CLI's Go build peaked at 1,775 MiB, but only 424 MiB of that was anonymous memory, the heaps and stacks of its processes. Most of the rest was page cache, which the kernel drops when it needs the room, plus some kernel memory. A Docker image build looked like 2,072 MiB for the same reason. And a TypeScript type check that held 1,139 MiB with the whole machine available finished inside 2 GB with 970 MiB, because Node sizes its heap limit from the cgroup limit it finds. This post shows the numbers, the five traps behind them, and every script we used, so you can size a runner from your own builds instead of from a guess. TL;DR - Four of five builds fit in 2 GB. Only the Excalidraw Vite build needed more: 3,248 MiB of anonymous memory, killed at 2 GB, fine at 4 GB. - memory.peak counts page cache. The Go build and the Docker build showed 1,775 and 2,072 MiB, but their anonymous memory peaked at 424 and 355 MiB. Size from anonymous memory plus a margin, then confirm by running the build inside that limit. - Runtimes size their heaps from the cgroup limit. Inside 2 GB, Node's default heap limit was 1,120 MiB and the JVM's default maximum heap was 512 MiB. The type check used less memory at 2 GB than at 8 GB and still finished, about 24% slower. - The Gradle daemon keeps its memory after the build. Five seconds after gradlew exited, the daemon still held 1,048 MiB of anonymous memory. With --no-daemon, that dropped to under 1 MiB, and in our one-command runs the daemon gave no repeatable speed-up. - Limiting the docker CLI did not limit the build. The CLI's cgroup peaked at 40 MiB while the BuildKit container that did the work peaked at 2,072 MiB. - Wall times on a shared-CPU droplet are noisy: the CPUs reported 23.5% steal time across the runs we tracked. Trust the memory columns more than the time columns. Prerequisites - A Linux machine with cgroup v2 and systemd (any recent Ubuntu, Debian or Fedora). Check with stat -fc %T /sys/fs/cgroup, which prints cgroup2fs. - Root access, for systemd-run --scope and for dropping the page cache. - The toolchains for the builds you want to test. Our setup script installs Go, Node, Yarn, a JDK, Rust and Docker. - If you want to rerun our matrix as it is: a 4 vCPU, 8 GB machine and about two hours. We used a droplet on DigitalOcean (referral link). How we measured We used one DigitalOcean droplet, size s-4vcpu-8gb in fra1, with Ubuntu 24.04 and kernel 6.8. The kernel reports 7,941 MiB of memory and there is no swap. Every build ran in its own transient systemd scope: systemd-run --scope --slice=bench.slice --unit=p1-<build>-<limit>-<run> \ -p MemoryMax=2G -p MemorySwapMax=0 -p AllowedCPUs=0-3 -p OOMPolicy=continue \ /root/bench/wrap.sh <outdir> <timeout> <build command> These are cgroup limits on one droplet, not three real machine sizes. A real 2 GB runner has a smaller kernel footprint, a runner agent and often a Docker daemon in the same memory, so it has less room than our 2 GB scope. The 8 GB limit is above the 7.9 GiB that the droplet has, so the 8 GB column means "the whole machine". The rest of the setup: - CPU. Every scope was pinned to the same 4 vCPUs with AllowedCPUs=0-3, and nproc printed 4 inside each one. Compilers start about one job per CPU, so a 2 vCPU runner would use less memory and an 8 vCPU runner more. We did not measure other CPU counts. - Cold build, warm dependencies. We downloaded dependencies once before the runs: yarn install, go mod download, cargo fetch, the Gradle distribution and dependencies, and the base images for the Docker build. Before every run we deleted the build output and the compiler caches (excalidraw-app/build, GOCACHE, target/, Gradle's build/ and .gradle/), stopped any Gradle daemon, and dropped the page cache. That is a CI job that restores a dependency cache but not a build cache. - What we recorded. Wall time, the exit code, memory.peak at the end of the run, memory.events (how often the limit was hit, and OOM kills), and a sampler that read memory.stat every 100 ms for anonymous memory (anon) and page cache (file). - Repeats. Runs went in round-robin order: run 1 of every cell, then run 2, then run 3, so a slow period on the shared host does not land on one build. Builds ran slower than we planned, so to stay inside our droplet budget the third round covered only the 8 GB and 2 GB limits. That gives 3 runs per cell at 8 GB and 2 GB, and 2 at 4 GB. The tables show the median of 3, or the mean of 2 at 4 GB. Each build also had one warm-up run at 8 GB that we did not count; it downloaded Gradle and filled the image mirror. The builds, all pinned to exact commits: | Build | Command | Source | | --- | --- | --- | | Excalidraw app, Vite production build | yarn build:app:docker | excalidraw/excalidraw 8bcdca45 | | Excalidraw type check, 1,508 files | tsc -p tsconfig.json (noEmit is set) | same checkout | | PlantUML, Gradle 9.3.1 on JDK 21 | ./gradlew jar, daemon on and --no-daemon | plantuml/plantuml db06d70e | | GitHub CLI, Go 1.27.3 | go build ./cmd/gh | cli/cli 9490d204 | | Online Boutique frontend image, BuildKit 0.34.1 | docker buildx build | GoogleCloudPlatform/microservices-demo c7cb6d5b | | ripgrep 15.2.0, Rust 1.99.1 (one run) | cargo build --release --locked | BurntSushi/ripgrep tag 15.2.0 | Node was 24.22.2 with Yarn 1.22.22, Docker was 29.9.2 with Buildx 0.38.1. The results | Build | Anonymous peak at 8 GB | memory.peak at 8 GB | 8 GB | 4 GB | 2 GB | | --- | --- | --- | --- | --- | --- | | Excalidraw vite build | 3,248 MiB | 3,578 MiB | ok, 66 s | ok, 83 s | 3 of 3 OOM-killed (run 1 from the kernel log) | | Excalidraw tsc type check | 1,139 MiB | 1,271 MiB | ok, 59 s | ok, 62 s | ok, 73 s | | PlantUML Gradle, daemon | 1,143 MiB | 1,474 MiB | ok, 124 s | ok, 110 s | ok, 113 s | | PlantUML Gradle, --no-daemon | 1,144 MiB | 1,475 MiB | ok, 88 s | ok, 119 s | ok, 100 s | | GitHub CLI go build | 424 MiB | 1,775 MiB | ok, 141 s | ok, 198 s | ok, 169 s | | Online Boutique frontend, docker buildx build | 355 MiB | 2,072 MiB | ok, 131 s | ok, 129 s | ok, 110 s | Times are medians of 3 runs at 8 GB and 2 GB, and the mean of 2 runs at 4 GB. Memory columns are from the 8 GB runs. What the cgroup counter says vs what the build held (8 GB limit, median of 3) | | Value | Series | | --- | --- | --- | | Vite build | 3578 MiB | memory.peak | | Vite build | 3248 MiB | anonymous memory | | tsc check | 1271 MiB | memory.peak | | tsc check | 1139 MiB | anonymous memory | | Gradle (daemon) | 1474 MiB | memory.peak | | Gradle (daemon) | 1143 MiB | anonymous memory | | Gradle (no daemon) | 1475 MiB | memory.peak | | Gradle (no daemon) | 1144 MiB | anonymous memory | | Go build | 1775 MiB | memory.peak | | Go build | 424 MiB | anonymous memory | | Docker build | 2072 MiB | memory.peak | | Docker build | 355 MiB | anonymous memory | _memory.peak includes page cache; anonymous memory is the sampled peak of anon in memory.stat (100 ms). One s-4vcpu-8gb droplet, 4 vCPUs, 2 November 2026._ Three things stand out. Only one build reached the 2 GB limit at all. The max counter in memory.events, which counts how often a cgroup's usage was about to go over its limit, stayed at 0 for every other run. Memory use at 4 GB and at 8 GB was almost the same for every build, so the extra 4 GB bought nothing. And the gap between memory.peak and anonymous memory is large for exactly the builds that read and write many files: the Go compiler and BuildKit. The single Rust build, ripgrep 15.2.0 with cargo build --release, fits the same pattern: 896 MiB memory.peak, 572 MiB anonymous, 61.1 s. We ran it once at 8 GB only, because the full matrix did not fit our time budget. Trap 1: memory.peak counts page cache memory.peak is the highest value of memory.current that the cgroup reached. memory.current charges the cgroup for everything it caused to be in memory, and that includes page cache : the source files the compiler read, the object files it wrote, the layers BuildKit unpacked. Page cache is reclaimable. When the cgroup gets close to its limit, the kernel drops clean cache pages and writes back dirty ones before it ever considers killing a process. Anonymous memory is the part that cannot go anywhere without swap: heaps, stacks, the compiler's working data. memory.stat reports it as anon. That, plus a smaller amount of kernel memory (37 to 136 MiB in these builds), is what has to fit. Our sampler read it every 100 ms, so it can miss a shorter spike. memory.peak and the max counter cannot miss one, and they show that no build except Vite at 2 GB ever reached its limit. The safe test is still the one we ran: the build inside the limit you plan to buy. The Go build of the GitHub CLI shows the difference well. Its peak was 1,775 MiB. Anonymous memory never went over 424 MiB; about 1,400 MiB was page cache from the module sources and the build cache that go build writes. At the 2 GB limit, the same build finished with the same peak, because 1,775 MiB is still under 2,048 MiB. With a smaller limit the kernel may reclaim that cache instead of failing the build, but we did not test below 2 GB, so test the lower limit before you rely on it. So if a dashboard shows that your CI job "peaked at 1.8 GB", that does not mean a 2 GB runner is too small. Look at anon in memory.stat (or RSS in your container metrics), and then add a margin for the runner itself. Trap 2: a production build that is also a type check The Excalidraw build needed far more memory than anything else: 3,248 MiB of anonymous memory, against 1,139 MiB for a full type check of the same code. The reason is in its Vite config: checker({ typescript: true, eslint: envVars.VITE_APP_ENABLE_ESLINT === "false" ? undefined : { lintCommand: 'eslint "./**/*.{js,ts,tsx}"' }, // ... }), vite-plugin-checker runs the TypeScript checker during vite build too: in version 0.7.2, which Excalidraw pins, enableBuild defaults to true. The production .env turns ESLint off but leaves the type check on, and the build also writes source maps. So one vite build is Rollup, source maps and a full tsc run at the same time. At 2 GB the kernel killed it in all 3 runs, 69 to 122 seconds in, after the log said ✓ 1442 modules transformed. The kernel log names the cgroup and the process it chose: oom-kill:constraint=CONSTRAINT_MEMCG,nodemask=(null),cpuset=p1-vite-2G-r2.scope,mems_allowed=0,oom_memcg=/bench.slice/p1-vite-2G-r2.scope,task_memcg=/bench.slice/p1-vite-2G-r2.scope,task=MainThread,pid=77242,uid=0 Memory cgroup out of memory: Killed process 77242 (MainThread) total-vm:11451308kB, anon-rss:1138988kB, file-rss:4864kB, shmem-rss:0kB, UID:0 pgtables:29992kB oom_score_adj:0 Our wrapper's record of that run shows the kill. memory.events counted 39,825 times that the cgroup was about to go over its limit, and one OOM kill: vite build, 2 GB limit, run 2 $ cat /root/res/p1/vite/2G/r2/result.env rc=1 t0=1793637034.083018067 t1=1793637156.285208072 peak=2147483648 current_after=867889152 anon_after=801075200 file_after=38674432 $ cat /root/res/p1/vite/2G/r2/memory.events low 0 high 0 max 39825 oom 1 oom_kill 1 oom_group_kill 0 The process list right after the kill shows the second half of the build. The checker runs tsc as its own child process, and it was still running after Vite had died: 77265 1808 /bin/sh -c tsc --noEmit 77266 799108 node /root/src/excalidraw/node_modules/.bin/tsc --noEmit That tsc held 799,108 KiB (780 MiB) of resident memory under the 2 GB limit. Yarn reported Command failed with exit code 1, but the type check kept going until our harness stopped the scope. On a real runner it would keep using memory and CPU until the job ends. We did not split the 3,248 MiB peak at 8 GB between Rollup and the checker, so we cannot say exactly how much the type check adds. What we can say: if your bundler runs a checker, your build step needs the memory of both, and moving the type check to its own CI job is the first thing to try before you buy a bigger runner. Trap 3: runtimes size their heaps from the limit Node and the JVM both read the cgroup limit when they start and size their default heap from it. Our harness asks each runtime what it would use inside each limit: probe inside a 2 GB scope # what Node 24 and JDK 21 pick inside MemoryMax=2G (from p1.sh probe) $ cat /root/res/p1/probe-2G.txt nproc=4 memory.max=2147483648 node_heap_size_limit=1174405120 int ActiveProcessorCount = -1 {product} {default} size_t MaxHeapSize = 536870912 {product} {ergonomic} double MaxRAMPercentage = 25.000000 {product} {default} All four places side by side: | Inside | Node 24 heap_size_limit | JDK 21 default MaxHeapSize | | --- | --- | --- | | 2 GB scope | 1,120 MiB | 512 MiB | | 4 GB scope | 2,240 MiB | 1,024 MiB | | 8 GB scope | 2,240 MiB | 2,048 MiB | | whole droplet, no scope | 2,240 MiB | 1,986 MiB | Two consequences showed up in the runs. Heap use follows the limit. tsc --extendedDiagnostics prints Memory used, which is Node's heapUsed at the end of the run, in units of 1,000 bytes. With the whole machine, the type check of 1,508 files reported Memory used: 1018378K (median of 3, about 971 MiB). Inside 2 GB it reported 886903K (about 846 MiB), anonymous memory fell from 1,139 to 970 MiB, and the check finished about 24% slower (median 72.7 s against 58.8 s). The 2 GB run was 9.5 to 14.2 seconds slower in each of the three rounds. In rounds 2 and 3, where we logged the CPU counters, its steal time was only 4 to 7 points higher, so steal explains only part of the gap. More frequent garbage collection under the smaller heap limit would explain the rest, but we did not record GC activity, so that is a hypothesis. A big heap number at a high limit says little about what the program needs. We expected this check to fail at 2 GB with a heap error, and it did not. Node stopped at 2,240 MiB even with more memory. On our 8 GB machine, Node's default heap limit was 2,240 MiB with a 4 GB scope, an 8 GB scope and no scope at all. We did not test a bigger machine, so check what your runner gives you with node -e 'console.log(require("v8").getHeapStatistics().heap_size_limit)'. If a build reports JavaScript heap out of memory, that is Node's own limit, not the kernel's. Set NODE_OPTIONS=--max-old-space-size=<MiB> explicitly instead of only buying more memory. The JVM takes 25% of the limit by default (MaxRAMPercentage=25), so a Maven build or a test JVM without -Xmx gets 512 MiB inside 2 GB. Gradle sets its own daemon heap, which brings us to the next trap. Trap 4: the Gradle daemon outlives the build PlantUML's gradle.properties sets org.gradle.jvmargs=-Xmx1g. That cap kept the build inside 2 GB: anonymous memory peaked at about 1,143 MiB with the daemon and 1,144 MiB without it, and neither came near the limit. The difference is what happens after gradlew exits. With the daemon, which is the default, the JVM stays alive and keeps its heap. Five seconds after the build, the scope still held 1,378 MiB, 1,048 MiB of it anonymous, in one process: 37292 1105976 /usr/lib/jvm/java-21-openjdk-amd64/bin/java --add-opens=java.base/java.lang=ALL-UNNAMED ... With --no-daemon, Gradle printed To honour the JVM settings for this build a single-use Daemon process will be forked and Daemon will be stopped at the end of the build, and five seconds after exit the anonymous memory in the scope was under 1 MiB. Anonymous memory around the end of the Gradle build (8 GB limit, run 1) | | -55 s | -50 s | -45 s | -40 s | -35 s | -30 s | -25 s | -20 s | -15 s | -10 s | -5 s | 0 s | +5 s | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | daemon (default) | 637 MiB | 857 MiB | 927 MiB | 982 MiB | 1053 MiB | 1059 MiB | 1066 MiB | 1073 MiB | 1082 MiB | 1110 MiB | 1115 MiB | 1143 MiB | 1054 MiB | | --no-daemon | 476 MiB | 516 MiB | 559 MiB | 807 MiB | 921 MiB | 970 MiB | 1067 MiB | 1072 MiB | 1080 MiB | 1084 MiB | 1112 MiB | 1144 MiB | 0 MiB | _Max of 100 ms samples in each 5 s bin, labelled by the end of the bin; 0 s is the moment gradlew exits, +5 s is the 5 s after. One run each, PlantUML jar task, JDK 21, Gradle 9.3.1._ On a CI runner, that leftover daemon sits in the same memory as every later step of the job: the Docker build, the integration tests, the upload. At 8 GB the median time was 123.5 s with the daemon and 87.5 s without (112.7 s and 99.7 s at 2 GB), The ranges overlap and CPU steal was high, so we see no repeatable speed-up from the daemon for one Gradle command per job. The daemon is built to pay off across several Gradle commands in the same job, which we did not test. If a job runs one Gradle command, use --no-daemon (or org.gradle.daemon=false). If it runs several, consider keeping the daemon (we did not test that case), and run ./gradlew --stop before the steps that need the memory. Trap 5: a limit on the docker CLI does not limit the build docker build is a client. In our setup the work ran in a BuildKit container (Buildx's docker-container driver), which has its own cgroup. Other drivers and CI executors lay out cgroups differently, but the CLI is only a client in all of them. We wrapped the docker buildx build command in the same kind of scope as everything else, and at every limit that scope peaked at 39 to 42 MiB: the CLI, streaming logs. To measure the build, we put the limit on the BuildKit container itself: docker buildx create --name p1d8gr1 --driver docker-container \ --driver-opt network=host --driver-opt image=moby/buildkit:v0.34.1 \ --driver-opt memory=8g --driver-opt memory-swap=8g --driver-opt cpuset-cpus=0-3 \ --buildkitd-config buildkitd.toml --bootstrap and read memory.peak from /sys/fs/cgroup/system.slice/docker-<container id>.scope. That container peaked at 2,072 MiB, of which only 355 MiB was anonymous: the Go compiler inside the build. Most of the rest was page cache from the image layers and the build's output, plus 136 MiB of kernel memory. This matters for runner sizing in two ways. Your CI's memory graph may not show the build at all, depending on whether it measures the job's process tree or the whole machine. And if a self-hosted runner limits only the job's process tree, a Docker build in that job can run outside the limit, so a "2 GB job" can push the host far past 2 GB. Check which cgroup your executor puts the Docker daemon in. Two method bugs that cost us a run The first 2 GB Vite run left no result at all. The kernel killed the Vite process, and then systemd stopped the whole scope, including our wrapper script, before it could write anything. The journal said so: p1-vite-2G-r1.scope: A process of this unit has been killed by the OOM killer. p1-vite-2G-r1.scope: Failed with result 'oom-kill'. systemd 255 sets DefaultOOMPolicy=stop, and scopes follow it. We set DefaultOOMPolicy=continue before the next 2 GB run (the published p1.sh also passes -p OOMPolicy=continue), and checked with a 64 MiB scope that the wrapper now survives a kill and records oom_kill 1. Runs 2 and 3 at 2 GB have full records. Then our rerun of run 1 failed too, for a different reason. systemd keeps a failed transient unit loaded, so starting a new scope with the same name was refused: Failed to start transient scope unit: Unit p1-vite-2G-r1.scope was already loaded or has a fragment file. By the time we saw that, the Docker cache tests for the next post were running on the same droplet, so we did not try again. Run 1 still counts as a kill: its kernel log line reads oom_memcg=/bench.slice/p1-vite-2G-r1.scope,...,task=MainThread,pid=36041, and our sampler, which runs outside the scope, saw the cgroup reach 2,048 MiB, with up to 1,985 MiB anonymous, before its last sample at 70.5 seconds. The published redo mode now runs systemctl reset-failed first. If you measure builds this way, set OOMPolicy=continue and give each run a unique unit name, or the runs that you care about most, the ones that fail, will be the ones with no data. A sizing table From these runs, for a 4 vCPU runner. The "smallest limit that passed" column is measured. The last column is our rule of thumb, not a measurement: a real VM also holds the OS, the runner agent and any service containers, so we pick the smallest size that leaves at least 1 GB above the anonymous peak. | Build like ours | Anonymous peak | Smallest limit that passed every run | Runner we would pick | | --- | --- | --- | --- | | Bundler that also type-checks (Excalidraw vite build) | 3,248 MiB | 4 GB | 8 GB (moving the type check to its own job may make 4 GB enough; we did not test that) | | Large type check on its own (tsc, 1,508 files) | 1,139 MiB at 8 GB, 970 MiB at 2 GB | 2 GB | 4 GB | | Gradle with a 1 GB daemon heap (PlantUML jar) | 1,143 MiB | 2 GB | 4 GB, with --no-daemon | | Go build of a mid-size CLI (gh) | 424 MiB | 2 GB | 2 GB | | Docker build of a Go service | 355 MiB inside BuildKit | 2 GB | 2 GB, plus what the Docker daemon and the other steps need | Hosted CI services list their machines by vCPU and memory, so you can match a build to a size. Bitrise, for example, lists every Linux machine type on its pricing page with its vCPU count and memory, such as 2 vCPU with 8 GB, and also sells a remote build cache for Gradle, Bazel and Xcode (checked on its public pages on 2 November 2026). Whatever you use, measure anonymous memory first, then pick the size. What we could not conclude - Three limits on one machine are not three machines. A real 2 GB runner has less page cache to spare, its own kernel, and a runner agent in the same memory. Leave a margin above the anonymous peak; our sizing table uses 1 GB. - CPU count changes memory. Every run had 4 vCPUs. The Go compiler, Rollup's workers and Gradle's workers scale with CPUs, so these numbers are not valid for 2 or 16 vCPUs. - Wall times are noisy. The droplet reported 23.5% CPU steal time across the 33 runs that our CPU counter log covered, and between 3.7% and 35.5% in single runs. The Go build took between 121.3 and 199.6 seconds at limits it never came close to. We do not read anything into a time difference between limits unless it repeats in every round, as the tsc gap did. - Two or three runs per cell is enough to see a failure repeat and a peak hold steady, and that is all. The anonymous peaks varied by up to 21% for the Go build (353 to 441 MiB at 8 GB) and up to 15% for Gradle, and 6% or less for Vite, tsc and Docker between runs of the same cell. - We did not split shared builds. We cannot say how much of the Vite build's memory is Rollup and how much is the checker, or how much of the Docker build's page cache is layer extraction. - Rust ran once. One ripgrep build at 8 GB, so no repeats and no 2 GB or 4 GB data. Run it yourself Create a 4 vCPU, 8 GB Ubuntu 24.04 machine, copy the files below to /root/bench/, and run: bash /root/bench/setup.sh bash /root/bench/p1.sh warmup # probes the runtimes, one unmeasured run per build bash /root/bench/p1.sh matrix # 3 rounds x 3 limits x each build (we stopped it after round 2) bash /root/bench/p1.sh round3 # what we ran as round 3: 8 GB and 2 GB only bash /root/bench/p1.sh redo # reruns any cell that left no result python3 summarize_p1.py /root/res/p1 Each run writes its own directory with result.env, memory.events, samples.json and the build log, so you can read any single run on its own. #setup.sh: toolchains, pinned sources, dependencies, registries #!/bin/bash # Droplet setup: toolchains, pinned sources, dependency prefetch, local registries. set -euxo pipefail export DEBIAN_FRONTEND=noninteractive mkdir -p /root/src /root/res cloud-init status --wait || true # first boot runs apt; wait for its lock fetch_sha() { git init -q "$1"; git -C "$1" remote add origin "$2"; git -C "$1" fetch -q --depth 1 origin "$3"; git -C "$1" checkout -q FETCH_HEAD; } fetch_sha /root/src/excalidraw https://github.com/excalidraw/excalidraw 8bcdca4526867433f99fdfcb55a063668db0c9dc fetch_sha /root/src/plantuml https://github.com/plantuml/plantuml db06d70e18e71839dd5e330ac4086f3845371e3b fetch_sha /root/src/cli https://github.com/cli/cli 9490d204a2ba95434153dedce99898ce9f281426 git clone -q --depth 1 --branch 15.2.0 https://github.com/BurntSushi/ripgrep /root/src/ripgrep fetch_sha /root/src/msd https://github.com/GoogleCloudPlatform/microservices-demo c7cb6d5bfd6ea3aed768634ebbcb98cb7a523712 curl -fsSL https://go.dev/dl/go1.27.3.linux-amd64.tar.gz | tar -C /usr/local -xz curl -fsSL https://nodejs.org/dist/v24.22.2/node-v24.22.2-linux-x64.tar.xz | tar -C /usr/local --strip-components=1 -xJ curl -fsSL https://sh.rustup.rs | sh -s -- -y -q --profile minimal --default-toolchain stable apt-get update -q apt-get install -y -q openjdk-21-jdk-headless build-essential git jq zstd python3 ca-certificates curl curl -fsSL https://get.docker.com | sh export PATH=/usr/local/go/bin:/root/.cargo/bin:/usr/local/bin:$PATH GOTOOLCHAIN=local npm install -g yarn@1.22.22 docker pull -q moby/buildkit:v0.34.1 docker pull -q registry:2.8.3 docker run -d --name reg-cache -p 127.0.0.1:5000:5000 registry:2.8.3 docker run -d --name mirror-hub -p 127.0.0.1:5001:5000 -e REGISTRY_PROXY_REMOTEURL=https://registry-1.docker.io registry:2.8.3 docker run -d --name mirror-gcr -p 127.0.0.1:5002:5000 -e REGISTRY_PROXY_REMOTEURL=https://gcr.io registry:2.8.3 # dependencies are downloaded once, outside the measured runs (cd /root/src/excalidraw && yarn install --frozen-lockfile --network-timeout 600000) (cd /root/src/cli && go mod download) (cd /root/src/ripgrep && cargo fetch --locked) # systemd stops a scope after an OOM kill by default; keep the wrapper alive to record the result mkdir -p /etc/systemd/system.conf.d printf '[Manager]\nDefaultOOMPolicy=continue\n' > /etc/systemd/system.conf.d/oom.conf systemctl daemon-reexec #wrap.sh: runs inside the scope and records the result #!/bin/bash # Runs inside the systemd scope. usage: wrap.sh OUTDIR TIMEOUT_S cmd... out=$1; tmo=$2; shift 2 cg=/sys/fs/cgroup$(sed -n 's/^0:://p' /proc/self/cgroup) echo "$cg" > "$out/cgroup" cat "$cg/memory.max" > "$out/memory.max" t0=$(date +%s.%N) timeout -k 15 "$tmo" "$@" > "$out/build.log" 2>&1 rc=$? t1=$(date +%s.%N) { echo "rc=$rc" echo "t0=$t0" echo "t1=$t1" echo "peak=$(cat "$cg/memory.peak")" echo "current_after=$(cat "$cg/memory.current")" awk '$1=="anon"||$1=="file"{print $1"_after="$2}' "$cg/memory.stat" } > "$out/result.env" cp "$cg/memory.events" "$out/memory.events" for p in $(cat "$cg/cgroup.procs"); do ["$p" = "$$"] && continue ps -o pid=,rss=,args= -p "$p" | cut -c1-400 done > "$out/leftover.txt" 2>/dev/null if [-n "${LEFTOVER_WAIT:-}"]; then sleep "$LEFTOVER_WAIT" echo "current_later=$(cat "$cg/memory.current")" >> "$out/result.env" awk '$1=="anon"{print "anon_later="$2}' "$cg/memory.stat" >> "$out/result.env" for p in $(cat "$cg/cgroup.procs"); do ["$p" = "$$"] && continue ps -o pid=,rss=,args= -p "$p" | cut -c1-400 done > "$out/leftover_later.txt" 2>/dev/null fi touch "$out/done" exit $rc #sample.py: polls memory.stat every 100 ms from outside the scope #!/usr/bin/env python3 """Poll one cgroup v2 directory every 100 ms until a done file appears. usage: sample.py CGROUP_DIR OUT_JSON DONE_FILE Records the maximum of anon, file, kernel and memory.current, plus a series. """ import json, os, sys, time cg, out, done = sys.argv[1:4] start = time.time() while not os.path.isdir(cg): if time.time() - start > 60 or os.path.exists(done): json.dump({"error": "cgroup never appeared"}, open(out, "w")) sys.exit(0) time.sleep(0.02) keys = ("anon", "file", "kernel", "shmem") mx = {k: 0 for k in keys} mx["current"] = 0 series = [] t0 = time.time() n = 0 while not os.path.exists(done): try: with open(os.path.join(cg, "memory.stat")) as f: st = {} for line in f: k, v = line.split() if k in keys: st[k] = int(v) with open(os.path.join(cg, "memory.current")) as f: cur = int(f.read()) except OSError: break n += 1 for k in keys: mx[k] = max(mx[k], st.get(k, 0)) mx["current"] = max(mx["current"], cur) series.append([round(time.time() - t0, 2), st.get("anon", 0), st.get("file", 0), cur]) time.sleep(0.1) json.dump({"max": mx, "samples": n, "interval_s": 0.1, "series": series}, open(out, "w")) #p1-cmds.sh: the builds, and what is deleted before each run #!/bin/bash # Build definitions for post 1. prep_* runs outside the cgroup, cmd_* inside it. export PATH=/usr/local/go/bin:/root/.cargo/bin:/usr/local/bin:$PATH GOTOOLCHAIN=local EX=/root/src/excalidraw PU=/root/src/plantuml GH=/root/src/cli RG=/root/src/ripgrep FRONTEND=/root/src/msd/src/frontend stop_gradle() { pkill -f GradleDaemon || true; pkill -f GradleWrapperMain || true; pkill -f KotlinCompileDaemon || true; sleep 1; } prep_vite() { rm -rf $EX/excalidraw-app/build $EX/node_modules/.vite $EX/excalidraw-app/node_modules/.vite; } cmd_vite() { cd $EX && yarn build:app:docker; } prep_tsc() { find $EX -maxdepth 2 -name '*.tsbuildinfo' -delete; } cmd_tsc() { cd $EX && node_modules/.bin/tsc -p tsconfig.json --extendedDiagnostics; } prep_gradle_daemon() { stop_gradle; rm -rf $PU/build $PU/.gradle; } cmd_gradle_daemon() { cd $PU && ./gradlew jar --console=plain --no-build-cache; } prep_gradle_nodaemon() { stop_gradle; rm -rf $PU/build $PU/.gradle; } cmd_gradle_nodaemon() { cd $PU && ./gradlew --no-daemon jar --console=plain --no-build-cache; } prep_go() { rm -rf /root/gocache /root/out; mkdir -p /root/out; } cmd_go() { cd $GH && GOCACHE=/root/gocache go build -o /root/out/gh ./cmd/gh; } prep_rust() { rm -rf $RG/target; } cmd_rust() { cd $RG && cargo build --release --locked; } prep_docker() { docker buildx ls --format '{{.Name}}' 2>/dev/null | grep '^p1d' | xargs -r -n1 docker buildx rm >/dev/null 2>&1 || true; } if ["${BASH_SOURCE[0]}" = "$0" ]; then "$@"; fi #p1.sh: probe, warm-up, matrix, round 3, redo, and the docker build cell #!/bin/bash # Post 1 matrix. usage: p1.sh warmup | p1.sh matrix set -u B=/root/bench R=/root/res/p1 mkdir -p $R source $B/p1-cmds.sh LIMITS=(8G 4G 2G) BUILDS=(vite tsc gradle_daemon gradle_nodaemon go rust docker) # rust ran once (warmup) only: the matrix did not fit the droplet time budget MATRIX_BUILDS=(vite tsc gradle_daemon gradle_nodaemon go docker) CPUS=0-3 log() { echo "$(date -u +%FT%TZ) $*" | tee -a $R/progress.log; } scope_run() { # unit limit out tmo cmd... local unit=$1 lim=$2 out=$3 tmo=$4; shift 4 python3 $B/sample.py /sys/fs/cgroup/bench.slice/$unit.scope $out/samples.json $out/done & local sp=$! systemd-run --scope --quiet --slice=bench.slice --unit=$unit \ -p MemoryMax=$lim -p MemorySwapMax=0 -p AllowedCPUs=$CPUS -p OOMPolicy=continue \ $B/wrap.sh $out $tmo "$@" wait $sp systemctl stop $unit.scope 2>/dev/null || true } docker_cell() { # lim out tmo tag local lim=$1 out=$2 tmo=$3 tag=$4 local name=$(echo p1d$tag | tr A-Z a-z) m=$(echo $1 | tr G g) docker buildx create --name $name --driver docker-container \ --driver-opt network=host --driver-opt image=moby/buildkit:v0.34.1 \ --driver-opt memory=$m --driver-opt memory-swap=$m --driver-opt cpuset-cpus=$CPUS \ --buildkitd-config $B/buildkitd.toml --bootstrap > $out/create.log 2>&1 local cid; cid=$(docker inspect -f '{{.Id}}' buildx_buildkit_${name}0) local cg=/sys/fs/cgroup/system.slice/docker-$cid.scope cat $cg/memory.max > $out/container_memory.max mkdir -p $out/cli python3 $B/sample.py $cg $out/container_samples.json $out/cli/done & local sp=$! scope_run p1-docker-$tag $lim $out/cli $tmo \ docker buildx build --builder $name --progress=plain --provenance=false --output type=cacheonly $FRONTEND wait $sp { echo "container_peak=$(cat $cg/memory.peak)"; cat $out/cli/result.env; } > $out/result.env cp $cg/memory.events $out/container_memory.events cp $out/cli/build.log $out/build.log docker buildx rm $name > /dev/null 2>&1 } run_cell() { # build limit run tmo local b=$1 lim=$2 r=$3 tmo=$4 local tag=$b-$lim-$r out=$R/$b/$lim/$r rm -rf $out; mkdir -p $out prep_$b sync; echo 3 > /proc/sys/vm/drop_caches; sleep 2 if [$b = docker]; then docker_cell $lim $out $tmo ${lim}$r else case $b in gradle_*) export LEFTOVER_WAIT=5 ;; esac scope_run p1-$tag $lim $out $tmo bash $B/p1-cmds.sh cmd_$b unset LEFTOVER_WAIT fi [$b = gradle_daemon] || [$b = gradle_nodaemon] && stop_gradle log "$tag $(tr '\n' ' ' < $out/result.env)" } probe() { # record what the runtimes see inside each limit for lim in "${LIMITS[@]}"; do systemd-run --scope --quiet --slice=bench.slice --unit=probe-$lim -p MemoryMax=$lim -p MemorySwapMax=0 -p AllowedCPUs=$CPUS \ bash -c 'echo "nproc=$(nproc)"; echo "memory.max=$(cat /sys/fs/cgroup$(sed -n "s/^0:://p" /proc/self/cgroup)/memory.max)"; echo "node_heap_size_limit=$(node -e "console.log(require(\"v8\").getHeapStatistics().heap_size_limit)")"; java -XX:+PrintFlagsFinal -version 2>/dev/null | grep -E " (MaxHeapSize|MaxRAMPercentage|ActiveProcessorCount) "' > $R/probe-$lim.txt 2>&1 done { echo "nproc=$(nproc)"; free -b | head -2; echo "node_heap_size_limit=$(node -e 'console.log(require("v8").getHeapStatistics().heap_size_limit)')"; java -XX:+PrintFlagsFinal -version 2>/dev/null | grep -E " (MaxHeapSize|MaxRAMPercentage) "; } > $R/probe-host.txt 2>&1 } case ${1:-} in warmup) probe for b in "${BUILDS[@]}"; do run_cell $b 8G r0 900; done log WARMUP-DONE ;; matrix) declare -A TMO for b in "${MATRIX_BUILDS[@]}"; do . <(grep -E '^t[01]=' $R/$b/8G/r0/result.env) w=$(python3 -c "print(int(float('$t1')-float('$t0')))") t=$((3 * w + 60)); [$t -gt 600] && t=600; [$t -lt 120] && t=120 TMO[$b]=$t done log "timeouts: $(for b in "${MATRIX_BUILDS[@]}"; do printf '%s=%s ' $b ${TMO[$b]}; done)" for r in r1 r2 r3; do for b in "${MATRIX_BUILDS[@]}"; do for lim in "${LIMITS[@]}"; do run_cell $b $lim $r ${TMO[$b]}; done done done log MATRIX-DONE ;; round3) # third run at 8G and 2G only: the full round did not fit the droplet time budget declare -A TMO=([vite]=300 [tsc]=381 [gradle_daemon]=600 [gradle_nodaemon]=351 [go]=414 [docker]=351) log "round 3 at 8G and 2G only" for b in "${MATRIX_BUILDS[@]}"; do for lim in 8G 2G; do run_cell $b $lim r3 ${TMO[$b]}; done done log MATRIX-DONE ;; redo) # rerun cells that left no result (systemd stopped the scope after an OOM kill) declare -A TMO=([vite]=300 [tsc]=381 [gradle_daemon]=600 [gradle_nodaemon]=351 [go]=414 [docker]=351) for b in "${MATRIX_BUILDS[@]}"; do for lim in "${LIMITS[@]}"; do for r in r1 r2 r3; do d=$R/$b/$lim/$r if [-d $d] && ! grep -q '^rc=' $d/result.env 2>/dev/null; then rm -rf $d.lost; mv $d $d.lost; log "redo $b $lim $r" systemctl reset-failed p1-$b-$lim-$r.scope 2>/dev/null # added after our run: a failed scope blocks its name run_cell $b $lim $r ${TMO[$b]} fi done; done; done log REDO-DONE ;; *) echo "usage: $0 warmup|matrix|round3|redo"; exit 2 ;; esac #buildkitd.toml: send base image pulls to the local mirror [registry."docker.io"] mirrors = ["127.0.0.1:5001"] [registry."gcr.io"] mirrors = ["127.0.0.1:5002"] [registry."127.0.0.1:5000"] http = true insecure = true [registry."127.0.0.1:5001"] http = true insecure = true [registry."127.0.0.1:5002"] http = true insecure = true #summarize_p1.py: medians per build and limit #!/usr/bin/env python3 """Summarize post 1 runs: medians per build and limit over the measured runs (r1..r3).""" import json, os, re, statistics, sys root = sys.argv[1] BUILDS = ["vite", "tsc", "gradle_daemon", "gradle_nodaemon", "go", "rust", "docker"] LIMITS = ["8G", "4G", "2G"] MiB = 2 ** 20 def env(path): d = {} if os.path.exists(path): for line in open(path): if "=" in line: k, v = line.strip().split("=", 1) d[k] = v return d def events(path): d = {} if os.path.exists(path): for line in open(path): k, v = line.split() d[k] = int(v) return d def run_info(d, build): r = env(os.path.join(d, "result.env")) if not r or "rc" not in r: return None log = open(os.path.join(d, "build.log"), errors="replace").read() if os.path.exists(os.path.join(d, "build.log")) else "" if build == "docker": if not r.get("container_peak"): return None # warm-up run 0 recorded no container numbers (builder name case bug) ev = events(os.path.join(d, "container_memory.events")) smp = json.load(open(os.path.join(d, "container_samples.json"))) peak = int(r["container_peak"]) cli_peak = int(r["peak"]) else: ev = events(os.path.join(d, "memory.events")) smp = json.load(open(os.path.join(d, "samples.json"))) peak = int(r["peak"]) cli_peak = None rc = int(r["rc"]) wall = float(r["t1"]) - float(r["t0"]) if rc == 0: outcome = "ok" elif ev.get("oom_kill", 0) > 0: outcome = "oom_kill" elif "heap out of memory" in log or "Reached heap limit" in log: outcome = "node_heap" elif "OutOfMemoryError" in log: outcome = "java_heap" elif rc in (124, 137): outcome = "timeout" else: outcome = f"fail_rc{rc}" mx = smp.get("max", {}) return { "rc": rc, "outcome": outcome, "wall_s": round(wall, 1), "peak_mib": round(peak / MiB), "anon_max_mib": round(mx.get("anon", 0) / MiB), "file_max_mib": round(mx.get("file", 0) / MiB), "kernel_max_mib": round(mx.get("kernel", 0) / MiB), "samples": smp.get("samples"), "oom_kill": ev.get("oom_kill", 0), "max_events": ev.get("max", 0), "high_events": ev.get("high", 0), "after_mib": round(int(r.get("current_after", 0)) / MiB), "anon_after_mib": round(int(r.get("anon_after", 0)) / MiB), "cli_peak_mib": round(cli_peak / MiB) if cli_peak is not None else None, "later_mib": round(int(r["current_later"]) / MiB) if "current_later" in r else None, "anon_later_mib": round(int(r["anon_later"]) / MiB) if "anon_later" in r else None, "leftover_later": open(os.path.join(d, "leftover_later.txt")).read().strip() if os.path.exists(os.path.join(d, "leftover_later.txt")) else None, "leftover": open(os.path.join(d, "leftover.txt")).read().strip() if os.path.exists(os.path.join(d, "leftover.txt")) else "", } def med(xs): xs = [x for x in xs if x is not None] return round(statistics.median(xs), 1) if xs else None out = {} for b in BUILDS: for lim in LIMITS: runs = {} for rn in ("r0", "r1", "r2", "r3"): d = os.path.join(root, b, lim, rn) if os.path.isdir(d): info = run_info(d, b) if info: runs[rn] = info meas = [runs[k] for k in ("r1", "r2", "r3") if k in runs] ok = [x for x in meas if x["outcome"] == "ok"] out[f"{b}/{lim}"] = { "runs": runs, "n": len(meas), "n_ok": len(ok), "outcomes": [x["outcome"] for x in meas], "wall_med_ok": med([x["wall_s"] for x in ok]), "wall_med_all": med([x["wall_s"] for x in meas]), "peak_med": med([x["peak_mib"] for x in meas]), "anon_med": med([x["anon_max_mib"] for x in meas]), "file_med": med([x["file_max_mib"] for x in meas]), "peak_range": [min(x["peak_mib"] for x in meas), max(x["peak_mib"] for x in meas)] if meas else None, "anon_range": [min(x["anon_max_mib"] for x in meas), max(x["anon_max_mib"] for x in meas)] if meas else None, "wall_range": [min(x["wall_s"] for x in meas), max(x["wall_s"] for x in meas)] if meas else None, "after_med": med([x["after_mib"] for x in meas]), "anon_after_med": med([x["anon_after_mib"] for x in meas]), "cli_peak_med": med([x["cli_peak_mib"] for x in meas]), "later_med": med([x["later_mib"] for x in meas]), "anon_later_med": med([x["anon_later_mib"] for x in meas]), "max_events_med": med([x["max_events"] for x in meas]), } json.dump(out, open(os.path.join(root, "summary.json"), "w"), indent=1) print(f"{'cell':26} {'n':>2} {'ok':>2} {'wall_ok':>8} {'peak':>6} {'anon':>6} {'file':>6} {'after':>6} outcomes / ranges") for k, v in out.items(): print(f"{k:26} {v['n']:>2} {v['n_ok']:>2} {str(v['wall_med_ok']):>8} {str(v['peak_med']):>6} {str(v['anon_med']):>6} {str(v['file_med']):>6} {str(v['after_med']):>6} {v['outcomes']} wall{v['wall_range']} anon{v['anon_range']} peak{v['peak_range']} maxev={v['max_events_med']} cli={v['cli_peak_med']} later={v['later_med']}/{v['anon_later_med']}") Summary Most CI builds need less memory than the cgroup counter suggests, because memory.peak includes page cache that the kernel gives back under pressure. Measure anonymous memory, run the build inside the limit you want to buy, and check memory.events for max and oom_kill. Then look for the traps: a bundler that runs a type checker, a runtime that sizes its heap from the limit, a Gradle daemon that stays after the build, and a Docker build that runs outside your cgroup. In our runs, fixing any of those was worth more than doubling the runner's memory. _Originally published at devops-daily.com._

  47. Filtering Clients Is the Hidden Time-Killer for Freelancers If you're a freelancer, especially a senior developer or architect, what's truly scarce isn't usually clients. It's uninterrupted time for focused, productive work. Most people assume a freelancer's biggest problem is "not enough opportunities." But for developers who genuinely have the skills, the portfolio, and the reputation, opportunities are not the bottleneck. Inquiries come in daily. The real question is: how many of them are worth a serious conversation? One person says "just a simple landing page, React should do it." Another says "the tech stack is already decided, just implement to spec." Someone else leads with "budget's tight, but lots of future work down the line." And the inevitable closer: "ideally you're always available online." These opportunities might technically overlap with your skills on paper, but they don't match how you work, what project stage you thrive in, how much decision-making authority you need, what quality bar you maintain, or what communication rhythm you prefer. So you end up spending enormous amounts of time filtering clients, and for many senior freelancers, this is the single largest hidden drain on their time. The stronger your skills, the higher the filtering cost For an average freelancer, filtering a client might just mean a few extra messages. For a senior developer, the cost goes far beyond a handful of replies, because your core value isn't being responsive online. It's solving complex problems in a state of deep work. You're in the middle of refactoring a critical module, mentally holding data models, boundary conditions, type constraints, interface compatibility, and deployment risks all at once. Then a notification pops up: "We're looking for a React developer to build our company landing page. Can you finish it in 2-3 days?" Of course you can politely reply: "Sorry, I mainly work on complex SaaS products, architecture design, and long-term iteration projects. I don't take pure landing page gigs." That reply might only take three minutes. But the real cost is everything it takes to regain your focus afterward: reloading the mental model, restoring engineering judgment, and rebuilding your working context. For senior engineers, context switching is rarely a minor thing. Every switch costs you not just a few minutes of chat time, but valuable time that could have gone to architecture design, implementation, performance optimization, or system debugging. Consider a simple estimate. Say you get five obviously mismatched client inquiries per week. Each one costs about 20 minutes spent reading the message, evaluating alignment, drafting a reply, and regaining your working context. That's 100 minutes per week. Over 52 weeks: 5,200 minutes, or roughly 86.7 hours per year. At $100 per hour, that represents about $8,667 in potential billable time. At $150, it represents $13,000. These are opportunity costs, not necessarily lost revenue. And the time comes out of work that requires sustained focus. So the real question isn't "am I missing out on clients?" It's this: can mismatched clients be filtered out before they ever reach you? Existing remote work platforms make you visible without necessarily assessing alignment Platforms like Upwork, Toptal, LinkedIn, and various remote work communities help clients find you. That matters, of course. Their profile formats, however, often emphasize presentation more than detailed collaboration requirements. A profile is built for humans. It typically consists of a headshot, a headline, work history, skill tags, a portfolio, and testimonials. A freelancer's profile might read: Senior full-stack developer. React, Node.js, TypeScript, PostgreSQL, SaaS. I help startups build scalable web applications. This is a perfectly competent profile. A human reading it will understand that you've worked on SaaS, that you know React, Node.js, TypeScript, and PostgreSQL. But for precise matching, it's nowhere near enough. "React" can describe entirely different kinds of work: a marketing landing page shipped in three days, a large-scale front-end codebase refactor, building an early-stage SaaS front-end architecture from scratch, patching a legacy project, building a product from zero to one for a founder with no technical team, or implementing predefined tasks in a team where the CTO makes all the decisions. They all involve React. But the demands on the developer, the collaboration model, the boundaries of responsibility, and the value exchanged are completely different. If the platform only knows you "know React," it will happily push every client who "needs React" in your direction, and the filtering cost gets dumped entirely on you. The platform did its job: it established a connection. What it didn't do is evaluate whether that connection is worth making. That's the fundamental limitation of the profile. It's good at answering: who are you? What have you done? What do you know? It often leaves other questions unanswered: what kind of client are you actually suited to? What kind of project wastes your time? What collaboration model makes you ineffective? What requests should never be forwarded to you? A profile is lossy compression Here is the deeper problem. A profile isn't just imprecise, it compresses your professional experience because prospective clients rarely have time to read the source material. Consider how much of your actual professional context never makes it into a profile: the rationale behind architecture decisions, incident postmortems, refactoring trade-offs, detailed case studies, and documentation habits. A portfolio may amount to a million tokens, far more than a prospective client typically has time to review. So you compress: a career becomes a headline, a skill list, three portfolio thumbnails. The client compresses too: a genuine need becomes "looking for React dev, ASAP." Two lossy signals collide in a search box, and the platform calls the result "matching." Many collaboration opportunities are lost before the interview, in the compression. The information that could have revealed alignment never reaches the other person. Long-context networking reduces the need to replace rich source material with a short generic profile. You can share accessible supporting context, and the client's AI agent can review it for takeaways relevant to that client. A portfolio may amount to a million tokens, but this is not a promise that every AI agent can process it all in one pass. A listing is a knowledge base In the Opportunity Skill, your representation can include multiple listings. Your AI agent creates impressions of you from each listing to index it. Every listing serves as a knowledge base with offering and seeking fields. The offering introduces you and describes the services you market, supported by customer success stories, use cases, and what distinguishes your work from alternatives. The seeking describes your requirements for clients: engagement models you're open to, collaboration style, project stage, decision-making expectations, and your boundaries. Both fields accept URLs, so supporting material can extend far beyond their text limits. Your AI agent can call upload_attachments to make portfolios, case studies, architecture documents, or demo videos accessible via URLs, then include them in the listing. Each file can be up to 256 MiB, with 5 GiB of storage per user. Keep proprietary techniques and confidential client information out of listings. Material better reserved for selected clients can instead be shared in messages when appropriate. And listings are primarily written for AI agents to read. Each reader's AI agent can use its understanding of its user's interests and current focus to introduce you in a tailored way, surfacing the aspects of your knowledge base that matter to this client in this search. As your focus shifts, your AI agent can update the listing with your confirmation and delete conflicting or obsolete impressions of you. A profile asks: "How do I appear stronger?" A listing asks: "How do I get matched more precisely? How do I reduce irrelevant inquiries?" Consider the difference. A profile says: Senior full-stack developer. Proficient in React, Node.js, TypeScript, and cloud deployment. Extensive SaaS product experience. Strong communication skills. This is not wrong, but it offers little detail for assessing alignment. A listing's offering and seeking would express something closer to: Suited to early-stage SaaS or AI tool teams. Can translate vague requirements into deliverable full-stack features. Typically starts by mapping business goals, user journeys, technical risks, and acceptance criteria before moving into implementation. Can align priorities with founders in the absence of a complete PRD and break uncertain work into small releases with verifiable outcomes. Prefers long-term iterative partnerships. Not suited to one-off, short-term outsourcing projects. That paragraph carries far higher semantic density, supported by the full knowledge base: case studies, architecture decision records, and code. To a human skimming profiles, the first version might look perfectly polished. To an AI agent deciding whether you align with its user's needs, the second version, together with its supporting URLs, provides much more useful context. If you serve multiple market segments, such as building products from scratch and architecture audits, create distinct listings, each understandable on its own. After your AI agent creates a listing, it can provide you with the URL and a ready-to-use instruction for others' AI agents to read the content at the URL for details on specified aspects. Attach the URL and instruction to pitch decks, social media posts, or materials for similar purposes, so people and AI agents can access the full context behind a short introduction. You can also sign in to QuestMeet to view the listing and export it as an image. This Skill also indexes the knowledge base For a listing to appear in the Skill's search results, it must be indexed. Your AI agent distills its offering and seeking into impressions of you, creating 1 to 20 per call, each capturing only one aspect and carrying 1 to 5 tags. Maps business goals, user journeys, technical risks, and acceptance criteria before moving into implementation. Turns vague requirements into verifiable deliverables. Tags: Requirement Clarification, Full-stack Delivery, Acceptance Criteria. Prefers remote work and async communication. Advances projects through documentation, GitHub issues, milestone demos, and clearly defined acceptance criteria. Tags: Remote Work, Async Collaboration, Documentation, GitHub Issues. Values TypeScript strict mode, type safety, test coverage, and maintainable architecture. Suited to products that require sustained development and continuous evolution. Tags: TypeScript, Type Safety, Maintainability, Testing, Long-term Collaboration. Takes responsibility for architectural decisions, technology selection, and implementation strategy. Collaborates as a technical partner. Tags: Technical Decisions, Architecture, Engineering Leadership, Senior Developer. Notice what's not there: the exclusions. "Does not accept daily stand-ups." "Does not take projects focused solely on execution." Those live in the seeking field of the listing, not in the index. The division of labor is deliberate. Impressions of you capture only attributes you have and attributes of people you want to connect with, excluding attributes you lack or want to avoid in others. Semantic search uses those impressions for discovery, while the client's AI agent reviews exclusions in the listing when assessing alignment. "What I don't want" helps assess alignment rather than conveying negativity Many freelancers are reluctant to clearly state what they don't want. This is completely understandable. Write too many boundary conditions and you risk looking difficult. You worry clients will think you're inflexible. You worry about missing opportunities. So most profiles only say "what I can do." Almost no one says "what I don't do." But when AI agents help assess a match, "what I don't want" is critically important: it helps an AI agent distinguish a promising search result from a collaboration that conflicts with your requirements. Here's how the boundaries help. The founder's AI agent searches using up to five queries when requirements span distinct aspects. Semantic similarity to impressions can surface your listing, but does not prove suitability. The AI agent then reviews the offering, seeking, and supporting context, explaining what aligns with the requirements, what does not, and what remains unknown. Explicit exclusions can reveal a conflict before contact, but they do not guarantee that a mismatched client will never reach you. This isn't negative information. It helps assess alignment. Just as you define interfaces in TypeScript not to appear complex but to reduce errors, you define boundaries in a listing not to appear difficult but to reduce mismatched contacts before they happen. A profile is like a web page. A listing is more like a capability API with full documentation attached. The page says: "Here's my introduction. Please browse at your leisure." The API says: "Here are my capabilities, preferences, constraints, and the complete context behind them. Search me, read me, and only connect when the match holds." When someone contacts you, your AI agent reads first Some mismatched inquiries will still arrive through referrals, cold outreach, or group invites. This is where long-context networking pays off on the receiving end. Every message is a knowledge base too. Your AI agent reads messages together with members' offering and seeking fields, with each message and field initially truncated to 4096 characters. If that is insufficient to assess the conversation, it calls read_chat_messages for the full text. It conveys recent messages and recommends whether to follow up, wait, or leave. After you confirm a reply, it sends it in the existing chat if there are fewer than 20 messages, or starts a new chat with a summary and reply if there are 20 or more. It leaves spaces you intend to leave. A scheduled task in the environment of your AI agent can check messages daily, but the Skill itself does not create that schedule. And because messages are written for AI agents to read, your replies can be exhaustive instead of compressed: full reasoning, complete context, and URLs pointing into your knowledge base. The Skill instructs the sender's AI agent to explicitly state that the content at all included URLs must be read, but this does not guarantee every reader's processing capabilities. Treat claims as unverified unless you or your AI agent have verified them against supporting evidence. The same mechanism works when you hunt for clients yourself. Buyers' listings are knowledge bases: their requirements, engagement models, budget expectations. Your AI agent searches for buyers with your queries, reads their listings, and surfaces key takeaways. Each buyer's attention price sets the minimum attention reward for an outreach attempt. "Keen" and/or "Rich" badges indicate a paid QuestMeet subscription and may suggest a stronger willingness to engage, greater purchasing power, or both, but do not guarantee either. Why "inverted filtering" matters especially for freelance developers Conventional platforms emphasize "get more clients to see you." But what freelance developers often need isn't more clients. It's fewer wrong ones. This is highly practical, not theoretical. If a client just needs a landing page, you can of course do it, but that's not where you add the most value. If a client has already decided every technical choice and just needs someone to execute to spec, you can of course write the code, but that wastes your architectural judgment. If a project demands daily meetings, constant responsiveness, and frequent requirement changes with no decision-making mechanism, your output quality will be dragged down by the collaboration model itself. A good client isn't just "someone with a need." A good client is someone whose needs, project stage, decision-making style, budget, quality standards, and communication rhythm all align with yours. Historically, you've done all of this evaluation yourself: read messages, review requirements, ask questions, attend calls, identify risks, judge reliability, assess alignment, decide whether to keep talking. The Opportunity Skill moves some of this work upstream: semantic search retrieves relevant impressions of users and their listings, and the AI agent reviews their context and boundaries before recommending a connection. The aim is fewer avoidable conversations, not a guarantee that mismatched people cannot appear in search results. Many freelancers underestimate how much time client filtering consumes, because the time comes in fragments. Five minutes replying to an inquiry. Ten minutes reviewing a requirement. Twenty minutes on a "let's just chat briefly" call. Half an hour drafting a proposal that won't close. These fragmentary costs are hard to track, but they steadily eat into your development time. Worse, they erode your judgment. Senior engineering work requires continuity. System design, complex debugging, architectural refactoring, and performance optimization are difficult to pause and then pick back up without losing context. The value of the Opportunity Skill isn't just helping you find opportunities. It's giving your AI agent enough context to reduce routine evaluation work before conversations begin. Its message functions read QuestMeet spaces and chats, not your LinkedIn, Upwork, WeChat, or email inboxes. And because listings come with URLs that can travel with your materials, the same context can help people and AI agents understand you before they ever message you. The goal is less manual filtering and more time for development work that produces real output. Write down your first "what I don't do" now If you're already an experienced freelance developer, the most valuable first step isn't polishing your headline or stacking more skill tags. It's writing down one thing: what work do I not take on? Don't use emotional language. Don't write "I hate bad clients" or "I reject poor quality projects." Write clear, neutral professional boundaries for the seeking field of your listing. For example: I'm better suited to projects with clear business objectives where both sides define the scope together. I'm not suited to collaborations where requirements change constantly without a clear process for decisions and rapid execution is expected without room for technical judgment. Or: I prefer sustained iterative product development. I contribute to architecture design, technology selection, and continuous optimization. I don't accept isolated projects lasting less than three weeks or outsourcing roles focused solely on execution with no authority over technical decisions. Or: I prefer async remote collaboration, advancing projects through documentation, issues, milestone demos, and clearly defined acceptance criteria. I don't accept daily status meetings, expectations of constant availability, or collaboration models that rely on frequent interruptions from instant messages. These statements make your collaboration requirements easier to assess. Your AI agent distills positive attributes into impressions of you to support discovery, while exclusions in the listing help other AI agents evaluate whether to pursue the connection. Future opportunities may not pass through human eyes first. An AI agent may retrieve and assess them first. When a founder tells their AI agent: "Find me a senior full-stack developer suited to young SaaS teams, who can deliver independently, prefers async collaboration, and doesn't take brief outsourcing gigs", the question is: does your listing carry those signals, and does the knowledge base behind them hold up when an AI agent reviews it? Your time belongs in code, not in filtering noise. The real freedom of freelancing isn't that every client can reach you. It's that you can share the depth of your work beyond a short profile, let AI agents review the relevant context, and spend less of your own attention on avoidable mismatches. Long-context networking supports more informed conversations while leaving the final collaboration judgment with you. If you're using an AI agent that supports Skills, you can tell it right now: Draft a listing for my confirmation. The offering: my development services, supported by case studies and portfolio URLs. The seeking: sustained iterative partnerships with founders who respect technical judgment. Exclude daily status meetings, outsourcing roles focused solely on execution, and isolated landing page projects. Keep those exclusions in the listing, not in the impressions of me. After creating the listing, provide me with the URL and a ready-to-use instruction for others' AI agents to read the content at the URL for details on my relevant experience, working style, and client requirements. I can attach them to pitch decks, social media posts, or materials for similar purposes. Tell your AI agent to download and install the Opportunity Skill from QuestMeet/opportunity-skill

  48. X@51AITech · 12 views

    A CTA is not a button. It is a reason, an action and a promise you keep. cta-design: free Claude Code / Codex skill. Page + audience + action in; copy, layout, image prompt and checklist out. Get it: 51aitech/cta-design Follow @51AITech for more #ClaudeCode #ClaudeSkills t.co

  49. X@giumacedo · 2 views

    Asking an AI model to compare two long CSVs invites arithmetic mistakes. tiedout matches bank statements to invoices in code, then sorts each line into matched, likely, review or unmatched, with the reason. GillMacedo/tiedout

  50. DEV@mitchellcross2134 · 1 comment

    Go Product RAG: Reranking 50 Candidates for Better Retrieval Quality Reranking actually helps RAG retrieval quality when relevant product passages already appear in the candidate set but land below the results customers see. TL;DR: a more expensive model scores each candidate against the query and changes the order; it does not add missing candidates. For an e-commerce catalog, start by testing 50 retrieved passages and 5 displayed results, then keep the extra call only if a labeled evaluation shows a meaningful ordering gain within the search latency budget. This distinction matters when index cost is the main constraint. A reranker can make a broad candidate set more useful, but it cannot compensate for products that were never embedded, stale inventory, weak chunking, or a filter that removed the correct SKU. Treat it as a precision-stage component, not index-cost magic. When does reranking actually help RAG retrieval quality? Consider the query waterproof trail shoes wide toe box. First-stage vector retrieval may return the correct product description at rank 18 because the embedding also favors hiking boots, rain shoes, and generic trail-running copy. The passage is present. The ordering is wrong. A model that examines the full query-candidate pair can move that passage into the five displayed results. Now consider a discontinued color variant whose product passage was never indexed. No score assigned to the other 49 passages can recover it. Reranking improves ordering, never recall. This is the first runbook check because it prevents an expensive second model from masking an ingestion or indexing problem. The likely gain is largest when retrieval is wide and presentation is narrow. Retrieving 50 and showing 5 leaves room to correct ordering. Retrieving 5 and showing all 5 does not. Those numbers are evaluation settings, not universal defaults; tune them with labeled catalog queries and the latency budget of the search path. Keep two signals separate. Candidate recall asks whether at least one relevant passage exists in the retrieved pool. Ranking quality asks where the first relevant passage appears after scoring. If candidate recall is poor, work upstream on product coverage, chunk boundaries, metadata filters, or first-stage retrieval. If recall is healthy while useful passages routinely sit below the visible cutoff, test a reranker. Missing is not misplaced. That is the hard boundary. Measure before adding a call to every search Build a judgment set from actual catalog language: ambiguous category terms, attributes such as material and fit, exact model names, and long natural-language needs. Each query needs independently judged relevant passage IDs. Do not label from the current ranker alone, or the evaluation will merely reward its existing behavior. The main Go sample below makes one real rerank call. Its input contains product passages that first-stage retrieval has already selected; it is not an indexing example. The client uses an environment variable, an explicit HTTP method, bounded retries for HTTP 429, Retry-After when supplied, and a surfaced response body for non-success status codes. Those details matter because the call sits on every enabled search path. package main import ( "bytes" "fmt" "io" "net/http" "os" "strconv" "time" ) var payload = []byte(`{ "query": "waterproof trail shoes wide toe box", "documents": [ "Road shoe with a standard toe box", "Waterproof trail shoe with a wide toe box", "Insulated waterproof hiking boot" ], "top_n": 2 }`) func retryDelay(response *http.Response, attempt int) time.Duration { if seconds, err := strconv.Atoi(response.Header.Get("Retry-After")); err == nil { return time.Duration(seconds) * time.Second } return time.Duration(1<<attempt) * time.Second } func main() { key := os.Getenv("INFRAI_API_KEY") if key == "" { panic("INFRAI_API_KEY is required") } baseURL := os.Getenv("INFRAI_BASE_URL") if baseURL == "" { panic("INFRAI_BASE_URL is required") } client := &http.Client{Timeout: 8 * time.Second} for attempt := 0; attempt < 3; attempt++ { req, err := http.NewRequest(http.MethodPost, baseURL+"/ai/rerank", bytes.NewReader(payload)) if err != nil { panic(err) } req.Header.Set("Authorization", "Bearer "+key) req.Header.Set("Content-Type", "application/json") response, err := client.Do(req) if err != nil { panic(err) } body, readErr := io.ReadAll(response.Body) response.Body.Close() if readErr != nil { panic(readErr) } if response.StatusCode == http.StatusTooManyRequests && attempt < 2 { time.Sleep(retryDelay(response, attempt)) continue } if response.StatusCode < 200 || response.StatusCode >= 300 { panic(fmt.Sprintf("rerank failed: status=%d body=%s", response.StatusCode, body)) } fmt.Println(string(body)) return } panic("rerank rate limit persisted after retries") } Run that call across a fixed evaluation export, then compute candidate hit rate before reranking and ranking quality after it. If MRR rises while candidate hit rate stays fixed, the reranker is doing the job it can do. Add an evaluation at the displayed cutoff, such as success at 5, because an MRR improvement below visible results may have no product value. A query whose relevant SKU is absent must remain a miss after reranking; keep such rows in the set as a guardrail against confusing ordering with recall. An offline win is necessary, not sufficient. Reranking adds a call to every search. Compare end-to-end latency distributions, error rate, and result quality with and without that stage. Use a stable query sample and log candidate IDs before and after scoring so an operator can distinguish a retrieval miss from a ranking change. The team that owns the search objective must set the acceptance threshold; there is no verified universal value. Choosing an integration without pretending the models are equivalent Cohere, Pinecone, Weaviate, and Infrai are real options, but their documentation exposes different integration boundaries. That is an operational difference, not evidence that one produces universally better relevance. Use the same held-out judgments against every candidate. | Option | Documented integration boundary | What to verify in this catalog | |---|---|---| | Cohere Rerank | A dedicated reranking API accepts a query and documents. | Attribute-query quality, request limits, and added search-path latency. | | Pinecone rerank | Reranking sits alongside Pinecone's retrieval tooling and can score supplied documents. | Whether colocating these stages reduces ownership without constraining evaluation. | | Weaviate reranker modules | Reranking is attached to Weaviate search through provider integrations. | Module configuration, provider dependency, and degraded-mode behavior. | | Qdrant | A vector database that can supply the candidate stage before a separate reranker. | Self-managed operational load and the boundary between retrieval and scoring. | | pgvector | Vector similarity search inside Postgres; reranking remains a separate application stage. | Whether existing Postgres ownership outweighs specialized search features. | | Infrai | Verified vector-query and AI-rerank calls share one Bearer-authenticated REST surface. | Whether one contract reduces integration ownership; measure relevance and latency separately. | The concrete Infrai advantage is breadth behind one REST API and one key: adding reranking beside vector query is another endpoint rather than another SDK and credential set. Its public discovery surface is self-describing and reports full schemas, billing information, and runnable examples; the broader platform has 295 routes across 20 modules. Consistent per-call cost, vendor, latency, cache, and request metadata can help chargeback and incident correlation. None of that proves its reranker wins on this product corpus. There are real limitations and trade-offs. Cohere is a focused choice when a team wants a dedicated reranking contract. Pinecone deserves a test when retrieval already lives there. Weaviate is a natural candidate when search is built around its module system; Qdrant can fit teams prepared to operate a vector database, while pgvector can fit a catalog already governed in Postgres. Infrai is not the right fit when the team wants a single-purpose vendor or already has a settled retrieval and credential boundary. It fits when reducing backend integration count is itself an ownership goal. A catalog-specific judgment set settles the ranking question, not a feature checklist. No shortcut here. Production controls, verification, and rollback Put the reranker behind a runtime flag and preserve first-stage ordering for fallback. Give the rerank call a bounded deadline inside the overall latency budget. On a timeout or rejected call, return the original candidate order rather than failing product discovery. Still record the error and correlate it with the search request; graceful degradation is not silent failure. Retries need restraint. A rerank request is read-only, but retrying inside an already tight interactive deadline can amplify load and worsen the tail. On HTTP 429, honor Retry-After and apply exponential backoff only while enough request budget remains. A result delivered after the shopper leaves is not a recovery. Roll out to a small traffic slice and compare the approved relevance signal with the control. Watch candidate hit rate too; it should not change merely because a later ordering stage was enabled. If it does, the experiment paths are receiving different candidate sets. Roll back when visible-cutoff quality regresses, the extra call breaches the agreed latency budget, or dependency errors exceed the search-path tolerance. The flag should restore baseline ordering without an index rebuild. Index spending remains a separate line item. Do not shrink catalog coverage because a reranker looks promising. Test any cheaper index or smaller candidate-generation configuration as a new retrieval system, then remeasure candidate recall before accepting it. Once recall falls, reranking has nothing to work with. The keep-or-remove decision Keep reranking when three conditions hold together: relevant product passages are usually present in the broad pool, the reranker moves them into the small displayed set, and the measured gain pays for an additional dependency on every search. Remove it when candidates are already well ordered, when misses originate upstream, or when the operational budget cannot absorb the call. This design stays reversible. Retrieval owns candidate coverage; reranking is an optional ordering stage. That boundary makes relevance debugging and incident response much less ambiguous. References - Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks - Cohere Rerank documentation - Pinecone rerank documentation - Weaviate reranker integrations - Qdrant documentation - pgvector project

Older posts →