Mentions

Inside the Myers Diff Algorithm: How Git Finds Code Changes (And How to Build One in Vanilla JS) Inside the Myers Diff Algorithm: How Git Finds Code Changes (And How to Build One in Vanilla JS) Every single day, millions of software engineers run git diff, inspect pull requests on GitHub, or review merge conflicts in VS Code. We take for granted that when we modify a 2,000-line file, our version control system instantly identifies: - The exact three lines we deleted (highlighted in red with a -). - The four lines we inserted (highlighted in green with a +). - The unchanged surrounding code kept intact for visual context. Have you ever stopped to consider the mathematical problem behind this? If you have an original file with $N$ lines and a modified file with $M$ lines, there are mathematically thousands of valid ways to transform File A into File B. You could theoretically delete the entire file and re-type the whole thing from scratch—that is technically a valid diff, but it is completely useless to a human reviewer. The goal of a diff engine is not just to find any sequence of edits. It is to find the Shortest Edit Script (SES)—the absolute minimal number of additions and deletions required to turn one file into another. When building the Text Diff Checker for Urban Mixo, we avoided heavy npm dependencies like jsdiff and implemented the diff engine directly in vanilla JavaScript. Here is the graph theory behind Eugene Myers’ landmark 1986 diff algorithm, how it powers Git, and how to build a zero-dependency diff engine in the browser. --- 1. Diffs as a Directed Coordinate Graph In 1986, computer scientist Eugene W. Myers published a paper titled An O(ND) Difference Algorithm and Its Variations. Myers reframed what seemed like an abstract string-comparison problem into a classic graph search problem on a 2D Cartesian coordinate plane. Imagine comparing two sequences: - Original ($A$): [A, B, C, A, B, B, A] (Length $N = 7$) - Modified ($B$): [C, B, A, B, A, C] (Length $M = 6$) Myers represented these two files as an $(N + 1) \times (M + 1)$ grid: - The x-axis represents lines in the original file $A$ (from $0$ to $N$). - The y-axis represents lines in the modified file $B$ (from $0$ to $M$). - The search starts at the top-left origin $(0, 0)$ and must reach the bottom-right terminal $(N, M)$. (Original File A) A B C A B B A 0---1---2---3---4---5---6---7 C 0 | | | \ | | | | | 1 |---|---|---|---|---|---|---| B 1 | | \ | | | \ | \ | | 2 |---|---|---|---|---|---|---| A 2 | \ | | | \ | | | \ | 3 |---|---|---|---|---|---|---| B 3 | | \ | | | \ | \ | | 4 |---|---|---|---|---|---|---| A 4 | \ | | | \ | | | \ | 5 |---|---|---|---|---|---|---| C 5 | | | \ | | | | | 6 ----------------------------- (7, 6) The Three Rules of Movement: 1. Move Right ($x + 1$): Deletes a line from original file $A$ (Cost = 1 edit). 2. Move Down ($y + 1$): Inserts a line from modified file $B$ (Cost = 1 edit). 3. Move Diagonally ($x + 1, y + 1$): Occurs whenever line $A[x]$ matches line $B[y]$. Because the line is identical, it costs 0 edits. Finding the cleanest, shortest diff is mathematically identical to: > Finding the shortest path from $(0, 0)$ to $(N, M)$ while taking as many free diagonal shortcuts as possible. --- 2. The Dynamic Programming Baseline: Longest Common Subsequence (LCS) Before exploring Myers' greedy optimization, it helps to understand the classic Longest Common Subsequence (LCS) algorithm using dynamic programming. If you find the longest common sequence of lines shared between both files in identical order, everything else is simply an insertion or a deletion: $$\text{Shortest Edit Distance} = (N + M) - 2 \times |LCS|$$ A Zero-Dependency LCS Implementation Here is how we built the foundational LCS matrix in browser memory using typed arrays (Int32Array) for cache-friendly memory locality: /** * Computes the Longest Common Subsequence (LCS) edit matrix. * Implemented with typed Int32Arrays to prevent V8 memory thrashing. */ function computeLCSMatrix(arr1, arr2) { const m = arr1.length; const n = arr2.length; // Allocate matrix using flat typed buffers const dp = Array.from({ length: m + 1 }, () => new Int32Array(n + 1)); // Build LCS table for (let i = 0; i < m; i++) { for (let j = 0; j < n; j++) { if (arr1[i] === arr2[j]) { dp[i + 1][j + 1] = dp[i][j] + 1; // Take diagonal shortcut } else { dp[i + 1][j + 1] = Math.max(dp[i + 1][j], dp[i][j + 1]); } } } // Backtrack from (m, n) to (0, 0) to assemble the shortest edit script const editScript = []; let x = m; let y = n; while (x > 0 || y > 0) { if (x > 0 && y > 0 && arr1[x - 1] === arr2[y - 1]) { // Unchanged line editScript.unshift({ type: 'equal', value: arr1[x - 1] }); x--; y--; } else if (y > 0 && (x === 0 || dp[x][y - 1] >= dp[x - 1][y])) { // Line inserted into modified file editScript.unshift({ type: 'add', value: arr2[y - 1] }); y--; } else { // Line deleted from original file editScript.unshift({ type: 'delete', value: arr1[x - 1] }); x--; } } return { diff: editScript, similarity: ((2 * dp[m][n]) / (m + n)) * 100 }; } This dynamic programming model runs in $O(NM)$ time and space complexity. For files with several hundred lines, it executes in under 2 milliseconds directly inside browser memory. --- 3. Why Myers’ $O(ND)$ Algorithm Is Revolutionary The standard dynamic programming matrix above has an inefficiency: it computes every single cell in the $(N \times M)$ grid, even if the two files are 99% identical! If you modify two lines in a 10,000-line codebase, an $O(NM)$ algorithm computes $10,000 \times 10,000 = 100,000,000$ operations. Myers realized that software revisions are rarely completely rewritten; they are mostly identical with a small number of edits ($D$). Instead of searching the entire coordinate space, Myers’ algorithm searches by increasing edit distance $D = 0, 1, 2, 3...$: 1. Group by Diagonals ($k$): Myers defined diagonal lines across the grid using the constant $k = x - y$. Moving right (deletion) moves you to diagonal $k + 1$. Moving down (insertion) moves you to diagonal $k - 1$. 2. Greedy Traversal: For each edit step $D$, the algorithm determines the furthest point reachable on each diagonal $k$. After taking an edit step (horizontal or vertical), it immediately slides along all available free diagonal matches (identical lines) as far as possible (a "snake"). 3. Early Termination: The moment a path reaches $(N, M)$, the algorithm halts. Because its time complexity is $O(ND)$ (where $D$ is the number of differences), if two large files differ by only 5 lines, $D = 5$. The algorithm finishes in a fraction of a millisecond, searching only a tiny sliver along the central diagonal. This is why Git can diff massive codebases almost instantly. --- 4. Line-by-Line vs. Word-by-Word Granularity When building a user-facing diff tool like our Text Diff Checker or our Universal Word Counter, an essential architectural decision is tokenization boundaries: Line-by-Line Tokenization: text.split('\n') Word-by-Word Tokenization: text.split(/(\s+)/) - Line-by-Line: Ideal for source code (Python, JavaScript, Go, JSON), where formatting, line endings, and indentation scoping dictate logic. - Word-by-Word: Critical for prose, contract legal review, and academic essays. If an author changes one word inside a 200-word paragraph, a line-by-line diff flags the entire paragraph as deleted and re-created in green. A word-level tokenization cleanly isolates the single altered phrase. --- 5. The Security Imperative: Zero-Server Code Comparison Beyond algorithmic elegance, there is a serious data security argument for in-browser diffing. Consider what developers paste into diff checkers: - API access tokens and .env configuration files. - Proprietary algorithms and unreleased source code. - Database SQL dumps with customer records. - Pre-release legal terms and NDA contracts. When you use conventional online diff tools, that data is transmitted across an HTTP POST request to a backend server. If that server logs requests, uses third-party analytics, or experiences a vulnerability, your confidential code is compromised. By building on a 100% client-side architecture: - The array splits, the LCS matrix, and the DOM render execute in the browser's local sandbox memory. - Refreshing or closing the tab destroys the data from RAM. - There is no backend database to breach because there is no backend server involved in the computation. --- 6. Engineering Takeaways 1. Reframe problems into graphs: When faced with comparative string evaluation, transforming sequence operations into pathfinding along a coordinate grid often reveals the optimal solution. 2. Use typed arrays for numerical matrices: Allocating large 2D dynamic programming matrices using standard JavaScript arrays ([]) causes high garbage collection overhead. Pre-allocating contiguous buffers with Int32Array delivers significant runtime speedups. 3. Keep private tools on the client: Utilities that process sensitive intellectual property should be architected to execute locally in the browser, eliminating privacy liabilities and cloud server costs simultaneously. --- Resources & Open-Source Tools - Live Text Diff Checker: urbanmixo.online - Universal Word Counter: urbanmixo.online - Trust & Architecture Manifest: urbanmixo.online - Open-Source GitHub Repository: github.com/urbanmixo-tools How does your team handle text comparison in internal tooling? Have you implemented custom diff heuristics for domain-specific files? Share your thoughts below!

刷到 pocket-id pocket-id/pocket-id 这个，自托管登录只认 passkey 不设密码，看着是挺省事，就不知道接一堆服务的时候会不会翻车 t.co

Location: Delhi NCR, India (UTC+5:30) Remote: Yes Willing to relocate: Yes (would need visa sponsorship outside India) Technologies: Python, TypeScript, SQL, FastAPI, Django, React, Next.js, Postgres, MongoDB, Docker, Kubernetes, Cloudflare Workers, LLM agents, MCP, RAG, evals Résumé/CV: drive.google.com GitHub: github.com/trakshan-mishra Email: trakshanmishra477@gmail.com I'm Trakshan, a backend and AI engineer, about two years in. These days I build the Docker/K8s environments that AI agents get tested in, and when an agent fails I turn that into a regression test. Before this I did backend work on Postgres and FastAPI. I cut API latency by 35% on one project and served ML models at 150 req/s on another. On the side I built DiffContext (pypi.org), which picks which code to hand an LLM for a change. On 128 tasks the pass rate went from 5.5% to 25.8% with about 90% less code. Later I found problems in my own benchmark and publicly took back three of my claims. I also built leakmap, a CI check that tells you when your app sends personal data or secrets to a third party, and which vendor and country gets it. I've had fixes merged in Apache Superset, Kubeflow, Opik, Arize Phoenix and facebook/astryx, and I'm a co-author on a PostgreSQL segfault fix. Looking for backend or AI/LLM roles, remote or relocation. Can start soon.

OMP vs OMH Current i try to optimize gpt & claude models in Oh-My-Hermes it is working pretty good. if u want to upgrade your herms-agent intelligence just install once OMH check: rlaope/oh-my-hermes t.co

TCOM, an image codec in 45 lines of code I use AI when coding. As for the AI disclosure. Onto the codec itself, I deleted my previous post about this because that iteration was not what I wanted to be seen and advertised in this space, I've opted for this version. TCOM as far as I've tested has beaten QOI on average. Of course, QOI is not built for performance alone, but QOI is a very efficient codec, and I wanted to test against it. There is tcom.c, tcom_dependency.c, and tcom_readable.c. A fair warning however, this codec was in no way designed for readability. Started as a code golf project and transformed into a performance and compactness focused codec. The github is OzzyMitchell/tinycodec As for why I didn't test against libpng or oxipng or others, it would take actual hours even on my 9950x3d, and since this is single threaded testing, you can imagine. I did do a smaller test of 640 images (20 images per category with 32 categories) which does include libpng effort 1, 3, and 6, and oxipng effort 4 alongside TCOM and QOI. This is also released under Apache 2.0. I didn't include any actual documentation or otherwise but I will write some documentation if some level of interest is attained.

@Luisanarchive Readest, es de codigo abierto y es buena, hasta ahora no me ha dado ningun problema readest/readest

UIと演出改善用スキルを試してみよう gamedev-skills/awesome-gamedev-agent-skills

Morning Brief 2026-11-03 Early morning brief from my experimental MorningNews AI-assisted by Grok 1.8.1 Grok: github.com/robertolofaro/supportmaterial/blob/mas… Free subscription: patreon.com t.co

Command palette now with bangs support I made a post a couple of weeks back about an extension I started working on, simply emulating the command palette from Zen/Arc. I've made a couple of tweaks since (partially from user feedback) then and thought I'd share again. It now supports bangs, based on the official Helium list. It also supports a separate shortcut for editing your current URL. I think it's in a pretty solid place now but would love to improve on it if people have suggestions. The goal here is to simply reproduce the palette alone, and make it feel like its a native part of the browser. ethantheb/float preview.redd.it

How to Implement Long-Term Memory for AI Companions: Pinning, Compaction, and Lessons from Mem0 and Letta A user tells their AI companion on Monday that they are allergic to peanuts. On Thursday they ask for a snack idea. The model suggests peanut butter cookies. Nothing crashed. The fact was stored somewhere. It just was not in front of the model when it mattered. That is the core problem of long-term memory for companion apps and personal agents. It is not really a storage problem. It is a question of what the model sees on each turn, and what happens to everything else when the conversation outgrows the context window. I work on Sipplay, an AI character chat and interactive story product. Our users hold conversations that run for weeks, so we have spent a lot of time on this. In this post I will walk through three questions every memory system has to answer, show how two of the strongest open-source projects answer them, and explain the choices we made. Three questions every memory system answers However the architecture diagram looks, a memory system for a conversational agent makes three decisions: 1. What is always in context? Some facts are too important to leave to retrieval: who the user is, hard constraints, the current relationship or task. 2. What happens at compaction? When the conversation is too long, something gets summarized, truncated, or moved out. The question is what survives that step. 3. What gets retrieved, and when? Everything not in context must be found again. That means deciding when to search, what to search for, and which of several similar records is still true. Most "my AI forgot" bugs come from one of these three, and they need different fixes. A bigger context window helps with none of them for long: it only postpones question 2. Mem0: a memory layer you bolt onto any agent Mem0 (around 68,000 GitHub stars at the time of writing, Apache-2.0) is the most popular open-source memory layer. It sits beside your agent rather than inside it. The basic loop from its README is two calls: from mem0 import Memory memory = Memory() # before replying: fetch what is relevant to this message relevant = memory.search(query=message, filters={"user_id": user_id}, top_k=3) # after replying: let Mem0 extract memories from the exchange memory.add(messages, user_id=user_id) Mem0 keeps memory at user, session, and agent level, so the same store can hold "Alice prefers dark mode" and "this support session is about billing". The interesting part is how its extraction changed. In its April 2026 algorithm update, Mem0 moved to single-pass, ADD-only extraction: one LLM call per exchange, no UPDATE or DELETE operations. The README puts it plainly: "Memories accumulate; nothing is overwritten." Conflicts are handled at read time instead, with: - Multi-signal retrieval: semantic similarity, BM25 keyword matching, and entity matching scored in parallel and fused. - Entity linking: entities are extracted and linked across memories to boost retrieval. - Temporal reasoning: time-aware ranking that picks the right dated instance for questions about current state, past events, or upcoming plans. Mem0 reports 92.5 on LoCoMo and 94.4 on LongMemEval with this approach, at about 7,000 tokens per query. Note the caveat in their own README: those scores come from Mem0's managed platform, which includes optimizations not in the open-source SDK. What Mem0 gets right: it treats memory as an append-only log plus a smart reader. Writes are cheap and never destroy information. "The meeting moved from Thursday to Friday" becomes two dated facts, and the reader's job is to pick the current one. What to watch: nothing is always-in-context by default. If a fact must never be missed, like an allergy, you are relying on retrieval to surface it every time it matters. And the quality of "pick the current one" now depends entirely on ranking. Letta: an agent that manages its own context Letta started life as MemGPT, the research project that framed LLM memory as an operating-system problem: a small, fast main context and a large external store, with the model paging information between them. The original repository (about 25,000 stars) is now archived as V1. Active development has moved to letta-code, which Letta calls an agent harness. Letta answers the three questions very differently from Mem0. Memory belongs to the agent, and the agent edits it itself. Always in context: memory lives as Markdown files in a git-versioned memory filesystem (MemFS). According to the Letta docs, files under system/ are in the system prompt on every turn. Everything else stays out of context: the agent sees the file tree and reads what it needs. Compaction: Letta has a background process it calls "dreaming". Subagents review recent conversations, consolidate lessons, and update memory without interrupting the active session. Crucially, you can trigger it on compaction: const agentId = await client.createAgent({ persona: "You are a support engineer who learns each customer's environment.", dreaming: { trigger: "step-count", // "off" | "step-count" | "compaction-event" behavior: "auto-launch", // "reminder" | "auto-launch" stepCount: 25, }, }); That compaction-event trigger is the important idea. The moment you are about to throw away detailed history is exactly the moment to decide what deserves to be kept. What Letta gets right: a clear split between "always visible" and "available on request", and a deliberate step that runs when context is compressed. Because memory is git-versioned, every change the agent makes to its own memory is inspectable and reversible. What to watch: self-editing memory means the agent decides what matters. That fits a personal assistant that learns your environment. In a companion app, users often want to decide for themselves which details are sacred. How we do it at Sipplay Our users are not configuring an agent. They are in the middle of a story, and they notice instantly when a character forgets a promise. So we combined ideas from both camps, and added one control we think is essential for companion apps: the user decides what is pinned. Our context for each reply has four layers: | Layer | What it holds | How it gets there | |---|---|---| | Pinned Memory | Details the user chose to pin | Included in the model's context on every turn | | Recent messages | The immediate exchange | Sliding window | | Medium-term summary | The broader situation of the story so far | Rewritten as the conversation grows | | Long-term memory cards | Facts, preferences, relationship events, plans | Extracted from closed windows; retrieved on demand | 1. Pinning: the user's version of system/ Pinned Memory is our equivalent of Letta's system/ files, with one difference: the user controls it. When someone pins "Mira holds the archive key now" or "never call me by my old name", that text goes into the context sent to the model on every turn, however long the conversation gets. This gives a guarantee retrieval cannot give: the detail is always present. It does not guarantee the model always uses it correctly. That is still up to the model, and we say so in our product copy. But it removes an entire class of failure: "the fact existed, but nothing fetched it." Pins also sidestep the compaction problem entirely. Because they are injected separately on every turn, summarizing the conversation cannot erase them. 2. Compaction: summary and cards are different jobs When a conversation window closes, an extraction step writes two things from the same messages: a new medium-term summary, and a set of long-term memory cards. They do different jobs. The summary keeps the flow of the story. A card has to make sense on its own when it is retrieved weeks later, with no surrounding context. Our evaluations taught us two lessons here: - Unfinished plans fall through the cracks. In our English extraction tests (ten windows, 200 messages, 28 reference cards), models sometimes kept an upcoming trip in the summary but did not write it as a card. The next summary rewrite then dropped it, and the plan was gone. Our rule now is that unfinished plans which matter beyond the current window become cards, and get completed or expired later. - Recall is not the only metric. An extractor that writes every possible card scores well on recall and badly on everything else, because each extra card is a distractor at retrieval time. We score precision as well: how much of what was written deserved to be kept. One practical finding: two strong extraction candidates dropped to 80% and 60% valid JSON once we applied a 2,048-token output cap, because their reasoning used up the budget. Since extraction runs in the background after a window closes, a slower but reliable model is acceptable there. The same latency before every reply would not be. This is the same instinct as Letta's compaction-triggered dreaming: the compression step is where you decide what survives, so do it deliberately. 3. Retrieval: decide before you search Before any vector search, a small model decides whether this turn needs long-term memory at all, and if so, writes a retrieval plan: { "need_retrieval": true, "memory_types": ["relationship_event"], "entities": ["user", "Lin"], "time_scope": "most_recent", "search_query": "reason and outcome of the user's most recent argument with Lin", "confidence": 0.93 } The "no" cases matter as much as the "yes" cases. If the answer is already in the recent messages or the summary, searching again only adds a chance of pulling in an outdated record. In our 60-probe English test, the best candidate triggered retrieval on 29 of 30 cases that needed it and correctly skipped all 30 that did not. Others searched when the summary already had the answer. Then, unlike Mem0's ADD-only approach, our cards carry a status. Retrieval filters by user, character, namespace, and active, stale, or deleted state before ranking. When a meeting moves from Thursday to Friday, the Thursday card is marked stale rather than left to compete. We learned why the hard way. In an embedding test, two of three models ranked the outdated Thursday booking above the Friday update. Both were "relevant". Similarity alone cannot tell you which fact is still true. Side by side | | Mem0 | Letta | Sipplay | |---|---|---|---| | Always in context | Nothing by default; you inject search results | Files under system/, edited by the agent | Pinned Memory, chosen by the user | | Compaction | Not its job; it stores extracted facts as you go | Summarization plus "dreaming", optionally triggered on compaction | New summary plus long-term cards from each closed window; unfinished plans become cards | | Conflicting facts | ADD-only; resolved at read time with temporal ranking | Agent rewrites its own memory files | Cards marked stale or deleted; filtered before ranking | | When to retrieve | Every time you call search | Agent reads files when it decides to | Intent model decides per turn and writes a retrieval plan | | Best fit | Adding memory to an existing agent quickly | Long-lived agents that learn and self-organize | Long-running companion stories where users control continuity | None of these is "the right answer". They make different bets about who should control memory: the developer, the agent, or the user. What a personal agent should borrow If you are building a personal agent, whether a companion, an assistant, or a coding helper that knows your setup, here is the checklist I would start from: 1. Have a small, explicit always-in-context set. Hard constraints, identity, and current commitments. Keep it short, because everything in it competes for attention on every turn. Let the user see and edit it. 2. Treat compaction as a decision point, not cleanup. Run extraction when you compress, not only on a timer. Check specifically for plans and promises that are about to fall out of the summary. 3. Store time and status, not just text. Whether you go ADD-only with temporal ranking like Mem0, or mark records stale like we do, the system must be able to tell "was true" from "is true". 4. Decide whether to retrieve before you retrieve. Test the negative cases: turns where the answer is already in context. 5. Evaluate each layer separately. Extraction quality, the retrieval decision, ranking, and final answer quality fail in different ways. One end-to-end score hides which one broke. 6. Isolate users and characters with zero tolerance. A memory from the wrong person is worse than no memory. Where we are now These ideas are running in Sipplay today. Pinned Memory is something users can try directly: pin a detail in a long story and watch whether the character keeps track of it fifty messages later. The evaluation figures in this post come from our internal development sets, not an independent benchmark, and we keep testing as we change models. If you are working on memory for agents, I would love to compare notes. What do you keep always in context, and what happens to it when the conversation gets compressed? Sources: Mem0 README and Letta README and memory docs, checked November 2, 2026. Star counts change daily. Sipplay figures are from internal development evaluations; the embedding corpus was Chinese, and the intent and extraction tests used English scenarios.

@CantonNetwork, the blockchain built for institutional assets, now ships an sbxenv.yaml in its base images repo. One sbx env run gives Claude Code cross compilers, GCC 13, syft and grype, locked to a network allowlist. canton-network/canton-base-images

i built oh-my-hermes it has 150+ omh skills, subagents(and kanban bot) orchestration auto routing, long term memory and coding workflow optimization. if u want to upgrade your hermes check it out: rlaope/oh-my-hermes t.co

[ Google Flow Takeout Organizer ] Download all your complete GOOGLE FLOW projects, including images, videos, prompts, and collections. everywherei/Google-Flow-Takeout-Organizer This small script lets you organize a takeout (a takeout is a download of your complete data from an email profile) from Flow. When you download a takeout, it comes with all the media files in a folder called “media,” but they're not organized, and you also have several .json files in a separate folder. This script extracts the data from the .json files and organizes the media. It also lets you choose whether to embed the metadata within the images or keep it separate, so you can read it with a prompt reader simply by uploading an image—since by default, the metadata is stored separately from each image. I recommend organizing your images into collections; for example, I don't recommend keeping them in the main folder—it's better to create named collections (folders) within the main folder. That way, you'll be able to better keep track of how many images have been downloaded.

@yacineMTB Give a drone a cadence brain, that would be interesting. Copy/paste connectomes from animals or just build on them with our open source brain. An attack drone fly would be awesome. muellerberndt/cadence

Kodi, ada ya shule, safari, dharura. Una malengo mangapi? 🎯 Yaweke yote kwenye Vauti na ufuatilie maendeleo yako mahali pamoja. Vauti haishikilii pesa zako, inakusaidia kufuatilia tu. Pakua app leo👇 github.com/rama-dhani24/vauti-releases/releases/l… #Vauti #Akiba #MalengoYaAkiba #Tanzania t.co

ocufesに触発され、とおいむかし遥か彼方の元年のoculus game jamの破片を発掘したので令和最新版にしておでかけ…なう。aiで2日(深夜にぽちぽちチャットしただけなのでソースも見てない人) haiatto/OGJ_Koekatamarin2026 t.co

@codepreneur247 @htmx_org @sama someone open sourced it 😱 bigskysoftware/htmx

@staaakh Delivery instructions are one place I'd want the customer's exact words handy. We're building KITE at Memoket: open-source agent memory that links recalled facts back to the original chat messages. memoket/memoket-kite

一个模型回答问题，容易把偏见写得很自信。 Karpathy 的 LLM Council 换了个思路：让多个模型分别回答、互相评审，最后再综合结果。 它不会自动产生“真相”，但能让分歧和薄弱点更早暴露。适合复杂判断，不适合每个小问题都开一桌模型会议——成本和时间都更高。 karpathy/llm-council #GitHub #大模型 #AI工具

Embed 100 million sentences in 13 seconds on a CPU. No GPU, no API bill. I just released fse 2.0, an inference engine for static embedding models (Model2Vec / POTION, static Sentence Transformers models, classic word vectors). It runs on plain CPUs: 100 million WikiText sentences in 13.46 seconds, embedded and written to disk (16 workers, AMD EPYC 9575F, 32 vCPU) RAG-sized chunks: about 1.27 million passages per second, at roughly 120 words per passage (16 workers, POTION-8M) Same model, same input, same machine: 21x faster than Model2Vec on one worker, 126x with 16 workers. Against the Rust port model2vec-rs it is 1.5x and 2.4x faster. Bonus: Fold in your linear classifier (regression, logit) and get speed on steroids. What that means for RAG: Re-embed everything whenever necessary! Build for large data, local AI, and rapid experiments. Embed at query time on the same box as your app. No GPU, no network round trip, no per-token cost. Store vectors as int8 if memory matters. Limits: static models are weaker than contextual embedders or transformers obviously. Use them for first-stage retrieval and put a reranker on top if you need precision. fse doesn't run transformers. All numbers come from a cloud server, not a laptop. Drop-in for Model2Vec users: from fse import StaticModel. There are integrations for LangChain, LlamaIndex and Haystack. Thoughts and feedback welcome 🙏 pip install fse Code and benchmark method: oborchers/Fast_Sentence_Embeddings

Built an AI Cyber Patrol Agent: rules score login attacks, Gemini writes the incident summary, n8n sends alert-only emails. Real results: 25/25 dev tests, 6/10 on a hidden set. Failures documented. Demo: cyber-petrolling1319.streamlit.app Code: ztsprofessionalaiid7-alt/cyber-petrolling t.co

@kazx68k SDカードからのLOADを想定しています。 説明すると少し長くなるので以下にStateFileを置きました。 github.com/mkomakonkon/MZ-2000/tree/master/PCB/MZ… mz2200.sta0をエミュと同じフォルダに置いて Control→LoadState→０を選んでからRUNです 古いエミュだとLOADできないかもしれません。beta8g以降を使ってください。 t.co

@btnaughton I wrote code that scores only residues in contact w/ the aligned chain. I wasn't sure it was useful. It still uses a PAE cutoff - I don't think ipDAE does. Otherwise quite similar except for the spelling :-) There's new code: DunbrackLab/IPSAE2. Both directions on one line.

I built independent firmware for a $10 router whose CPU mainline GCC has no -march for (RTL8196E / Lexra RLX4181) The public record says Lexra cores lack lwl/lwr/swl/swr. On my router's RTL8196E (Lexra RLX4181), a bare-metal census of 75 encodings under a custom exception handler found all four computing correctly, and found rotr silently executing as srl: no trap, just a wrong answer. That came out of building independent firmware for the TOTOLINK N150RT, which OpenWrt doesn't support and whose vendor never released source, on the only unit I have. It runs on Realtek's GPL Linux 2.6.30 and builds with Realtek's GCC 3.4.6; the boot verifier, eight drivers and six userspace programs are new. Claude Code (an AI coding agent) wrote the code while I ran the hardware side: wiring the serial console, every power cycle, and a yes for every flash write. Each device claim in the repo links to an unedited serial capture. What works (measured on the device): - rlxboot: Ed25519 + SHA-256 + an anti-rollback counter, A/B slots and a rescue copy. 10 of 10 power cuts mid-slot-write booted the other slot. - Signed self-update from the web UI, 38.8 s from upload to link up. - New drivers for Ethernet DMA, switch, SPI flash, watchdog, timer, GPIO, buttons and entropy; no vendor Ethernet driver in the image. 31 minutes of traffic, 2,363,511 frames, no stall. Doesn't do: WAN, Wi-Fi, TLS or secure boot (details in a comment). Hardest bug: my Ethernet driver lost transmissions at some frame lengths (263, 1,511, 1,512 bytes) but not others. The loader and the vendor's driver write a TX descriptor's three length fields equal; mine set m_len 4 bytes short of ph_len. Switching only that, on one boot: 220 of 220 pings answered vs 145 of 1,327. Why the short length breaks is still unknown. v1.1 is done. Before I decide what comes next, I'd love brutal feedback from people who've done embedded Linux: what would you have done differently, and what should come next? Repo: Jhongwe1/router-customFW

can i get some stars in my this github repo mohdshubair313/assurely 🥺

Diablo II: Resurrected, native on Mac, iPhone and iPad: sharper than the Switch with Metal 4 and MetalFX, the macOS version is installed and updated by a one-click Mac launcher, and include the game's PC interface/PC mouse and keyboard controls. Hi r/macgaming! **D2R Metal** is an open-source project that runs **Diablo II: Resurrected with Reign of the Warlock** natively on Apple silicon: on your **Mac**, your **iPhone** and your **iPad**. It started as a fork of [D2R Mobile](jhaizhou-ops/d2r-mobile), which did the original port, and has grown into its own project: a renderer rebuilt on Metal 4, a Mac launcher that installs and updates the game for you, saves you can trust, and as of 1.1 the game's own PC interface with a mouse and keyboard. **How it works:** the game's own ARM code, from the Nintendo Switch release, runs directly on your Apple chip. It's not an emulator, not Wine or CrossOver, and not streaming: the few instructions macOS and iOS can't run are rewritten ahead of time, and the Switch's graphics API is rebuilt on Metal 4. It plays fully offline, and the game itself (rules, drops, skills, stash) stays as Blizzard shipped it. **D2R Metal Launcher (Mac):** download it, point it at your own game files and press Install. It builds the game on your Mac in about 10–15 minutes, then updates the game and itself from the project's releases, can go back to the previous version, and repairs an install. It's signed and notarized: no Xcode, no Homebrew, no developer account. **Sharper than the Switch, on every device:** - the interface drawn at your screen's own resolution (up to 3840 pixels wide on the Mac), never stretched - MetalFX upscaling of the 3D world, the game's PC SMAA in place of FXAA, 16x texture filtering, accurate sRGB color - on the Mac, scenery shadows (the Switch only shadows characters) and shadow maps up to the PC's 4096 - a steady 60 fps: about 7 ms of GPU time per frame at native 1440p on an M6 Mac, and 60 fps on an iPhone 17 Pro with MetalFX, SMAA and 16x on **On the Mac, it plays like D2R on PC (new in 1.1).** With a mouse and keyboard you get the game's own PC interface (the PC HUD with the angel and demon statues, the PC menus, the gauntlet pointer) and D2R's PC keys: click to move and attack, right click for your right skill, Shift to stand still or compare, 1–4 belt, F1–F8 skills, I / C / T / Q panels, Tab map, Alt items, Esc menu. Press a button on a controller and the console interface comes back right away, with Xbox, PlayStation or Switch prompts. Full screen at native resolution, and it saves on every quit. **On iPhone and iPad:** touch controls and controller support, the same picture options (3D resolution 50–100% with MetalFX, SMAA and 16x filtering), a 30 fps power saver, saves when you swipe the app away, and iCloud save sync between devices when you build it with a paid developer account. iPhone 15 Pro, iPhone 16 and later, and iPads with an M chip or A17 Pro play as is; iPhone 12 to 14 with a Legacy Device Pack. For now the iPhone and iPad app is built from source with Xcode on a Mac (a free Apple ID works). **Saves you can trust:** the port went through a full audit, sanitizer and Metal validation runs, and a study of how the game itself saves. A failed save (a full disk, say) can no longer silently stop every later one, and every change is checked against replays that must match tick for tick. **What you need:** - a Mac with Apple silicon (M1 or later) on **macOS 27**, or an iPhone / iPad on **iOS / iPadOS 27** - your **own copy of the Switch version** (base game, Reign of the Warlock, update 1.0.34.0), dumped from your own Switch, with that console's keys The project contains no game files and never will. If you own the PC (Battle.net) version, this isn't for it: CrossOver is the way to go there. **Not there yet:** rebinding keys on the Mac, and an install on iPhone and iPad that doesn't need Xcode. Download, docs and source: PowerBeef/d2r-metal (the launcher is in Releases). Feedback and bug reports are very welcome. Happy to answer questions!

Discover AI - 58 free, interactive labs for learning AI/ML in 3 different reading mode. I built Discover AI, a free, open-source app with 58 hands-on labs for learning how AI works. The topics run from neurons and gradient descent to attention, RAG, agents, pretraining and fine-tuning. You move sliders or train a tiny model and watch what changes, and a short lesson sits beside each lab. Since I first shared it three weeks ago, I've added seven labs on how large models are trained, a simpler reading mode, desktop installers, and a version that runs in your browser: fazmin.github.io Every reference is double-checked. AI was used to help write these lessons, so there may be mistakes. Please point them out, let me know what’s confusing or missing, or open a PR. Contributors are welcome to access the project at github.com/Fazmin/AILearningGuide.

彻底成功，新词雷达2100🌟后，入选到AIsa官网案例 Track new AI terms with New Term Radar 通过页面上的安装按钮和一键安装到提示词，即可安装 英文版：aisa.one 中文版：aisa.one 项目地址：zhuyansen/new-term-radar t.co

Onyums: serve axum apps as Tor onion services with embedded Arti onyums turns an axum Router into a Tor onion service. Arti is compiled into your binary, so you don’t need a tor daemon or a torrc, and you don’t need to open any ports. use onyums::{OnionService, routing::get, Router}; #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { let app = Router::new().route("/", get(|| async { "Hello from Tor!" })); let handle = OnionService::builder().router(app).nickname("my_onion").serve().await?; println!("serving on {}", handle.onion_address()); handle.ready().await; // resolves once the descriptor is published tokio::signal::ctrl_c().await?; handle.shutdown().await; Ok(()) }use onyums::{OnionService, routing::get, Router}; #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { let app = Router::new().route("/", get(|| async { "Hello from Tor!" })); let handle = OnionService::builder().router(app).nickname("my_onion").serve().await?; println!("serving on {}", handle.onion_address()); handle.ready().await; // resolves once the descriptor is published tokio::signal::ctrl_c().await?; handle.shutdown().await; Ok(()) } The defaults are the safe ones and you turn things off if you don’t want them. Out of the box you get TLS inside the circuit, an address that stays the same across restarts, and a handle for readiness, health and metrics. It also supports client auth, raw TCP on other ports, and running several services on one Tor bootstrap. Everything is Rust, including the crypto. onyums-sk*n is the abuse protection layer. Onion services don’t see client IPs, and a lot of Tor users have JavaScript off, so it works with circuits and signed tokens. JS clients solve a proof of work, other clients get a CAPTCHA, and a slow tarpit is the last fallback. On top of that it has rate limiting and a WAF. It’s a normal tower layer, so you can use it in any axum app. Coming next: - Bring your own key, so an existing onion service can move to onyums and keep its address - Proof of work at the introduction point (Tor’s own Equi-X), on by default - A CLI for putting an existing local service behind an onion address without writing Rust - Further out, a framework layer on top of axum with file-based routing and server actions, built to work without JavaScript GitHub: basic-automation/onyums website: basicautomation.io crates.io: onyums 0.6, onyums-sk*n 0.2 I’d like to hear what you think of the API, and what you’d need before using it.

[Release] CleanWeb Tool for LangChain: 87% Token Compression for Web Scraping + Indirect Prompt Injection Defense (PyPI: langchain-x402-cleanweb) Hey everyone! 👋 One of the biggest headaches when building autonomous LangChain agents or web-grounded RAG pipelines is that raw HTML ingestion completely wrecks LLM context windows. A single news article or documentation page can easily chew up 25,000+ tokens just from navigation bars, advertisement containers, tracking scripts, and cookie banners—and worse, hidden prompt injections or zero-width steganography embedded in third-party DOMs can easily hijack your agent. To solve this, we just officially published **`langchain-x402-cleanweb`** to PyPI today! --- ### ⚡ What it does: 1. **87% Token Compression**: Strips boilerplate, ads, navigation markup, and cookie modals, returning high-fidelity, clean Markdown optimized for LLM context windows. 2. **Indirect Prompt Injection Defense**: Neutralizes hidden CSS text (`display:none`, `font-size:0px`), zero-width exfiltration characters, and malicious tracking links before your LLM reads the page. 3. **Multimodal Alt-Text Preservation**: Extracts descriptive image alt tags (``) for visual LLMs (like GPT-4o or Gemini Flash) while automatically neutralizing 1x1 tracking pixels (`[EXFILTRATION_IMAGE_BLOCKED]`). 4. **Zero-Overhead SPA Hydration**: Instant extraction of pre-rendered state from Next.js (`__NEXT_DATA__`), Nuxt.js (`__NUXT_DATA__`), and schema.org JSON-LD without spinning up heavy headless browsers. 5. **Standard LangChain Tool**: Fully compliant with `langchain_core.tools.BaseTool` supporting both sync `_run` and async `_arun` with Pydantic v2 validation. 6. **Machine-to-Machine x402 Micropayments**: Native USDC micropayments over Base, Polygon, Arbitrum, and Solana with pre-funded agent vaults. --- ### 📦 Quickstart Install directly from PyPI: ```bash pip install langchain-x402-cleanweb ``` Use it directly in Python: ```python from langchain_x402_cleanweb import X402CleanWebTool # Initialize tool (connects to our high-availability gateway) tool = X402CleanWebTool() # Scrape and get 87% token-reduced clean Markdown clean_content = tool.run("en.wikipedia.org") print(clean_content) ``` Plug it into any LangChain ReAct Agent: ```python from langchain.agents import initialize_agent, AgentType from langchain_openai import ChatOpenAI from langchain_x402_cleanweb import X402CleanWebTool llm = ChatOpenAI(model="gpt-4o", temperature=0) tools = [X402CleanWebTool()] agent = initialize_agent( tools=tools, llm=llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True ) response = agent.run("Find the core concepts on news.ycombinator.com without any ad noise.") print(response) ``` --- ### 🆓 Free Sandbox Tier Every session nonce comes with **5 free zero-auth trial calls** out of the box so you can test it immediately without needing API keys or wallet setup. * **PyPI**: pypi.org * **GitHub**: nohosa001-pixel/x402-cleanweb-agent Would love to hear your feedback on edge-case websites, token savings, and how you handle web security in your autonomous agents! 🚀

Caching a request body isn't enough if two first readers race for the stream. Karak's test starts two reads together, reads again, then checks receive was called once per chunk. It covers an empty body too: empty is a result, not a cache miss. github.com/grandimam/karak/blob/main/tests/test_r…

@CareerquilLTD Applied through Blockvora’s site. Former BigBasket senior SDET with Java, Playwright, Selenium, REST Assured and CI/CD experience, plus two shipped mobile products. Keen to discuss the QA role. Portfolio: github.com/Anandumv

Babai established quasipolynomial time; our earlier Lean formalization made his bound explicit at exp(O(log^5 n)), later sharpened to exp(O(log^3 n)) by Helfgott. Our paper and its formalization in Lean are below: Paper: arxiv.org GitHub: mahdi-jfri/GraphIsomorphismLog2

Building on top of the ecdsa.fail community effort. Here is my ~109k nonce/s (RTX 5090 x1) Fiat-Shamir nonce cranker jackylee0424/spookyfrog-gpu-filter t.co

家里十几台设备，晚上视频就卡。系统工具只给总流量，收费监控还要按年付。 NetworkManager 显示每块网卡实时速率、历史、IP/DNS 配置与局域网设备，能看带宽曲线。 borntoberoot/networkmanager

You can test cases like this on your own agent using Plumloom Autoeval. It's open source, with a CLI, MCP server, and CI release gates. AlchemyInCode/plumloom-autoeval-oss

Neat trick from Shopmon’s sbxenv.yaml: keep frontend/node_modules in its own sandbox volume. Your Mac’s node_modules and the Linux sandbox’s native packages never mix. Codex gets a clean toolchain via mise and a single postCreate step. FriendsOfShopware/shopmon

Harness: one sentence builds an AI team (free on GitHub) Would you build a team for work, or for fun? Reply and we'll answer the best one in a video. Which GitHub tool should I explain next? Harness is a free, open-source Claude Code plugin from GitHub that turns one sentence into a team of AI agents: describe a job ("design an agent team to research a topic") and it designs the team, for example researchers who dig and a fact-checker who checks each claim, and writes each helper's instructions as files you can read and edit. Would you build a team for work, or for fun? How to start: in Claude Code, paste /plugin marketplace add revfactory/harness, then the install line from the README. Harness is free (Apache-2.0). Claude Code needs a paid Claude plan: Claude Pro is $20/month, or $17/month billed yearly, or an Anthropic API account with pay-as-you-go, as of 1 Nov 2026; bigger teams use more of your plan. Safety: these helpers can run commands and edit files, so try it in a test folder and read every command before you approve it. 🔗 Links Harness on GitHub — revfactory/harness 9.3k stars, last updated 28 Sep 2026, as of 1 Nov 2026. Facts from the Harness README and Anthropic's Claude Code docs and pricing page. Not sponsored, not affiliated with revfactory or Anthropic. #shorts #ai #github #opensource #aiagents Follow @under60tools for more tools like this, explained simply.

@MatiasMatthews @webtkdev Funny enough, I’m building an open-source tool for exactly this 😄 It’s called ICM—helps agents manage screenshots without keeping every image in context forever. Still figuring out when keeping less just means looking again. messsiii/image-context-manager

Go ham, tag me so I can see what you cook: abouchedidxcode/open-source-hands

Stage your scene in 3D, pose characters and frame the shot before you ever hit generate, all in an open-source Rust IDE for AI art. 🔗 storytold/artcraft Credits: storytold/artcraft #artcraft #rust #opensource

[Update] CleanWeb v2.8.4: Multimodal Alt-Text Preservation, SPA Hydration Extraction, and Official LangChain & LlamaIndex Packages Released! Hey r/mcp community! We were blown away by the incredible response and discussion on our previous MCP CleanWeb post (over 6.5k views across the community!). Thank you so much for the thoughtful questions, benchmark requests, and feature suggestions. Based directly on community feedback, we just shipped **CleanWeb v2.8.4** and published companion integration packages across the major frameworks! --- ### 🛠️ What’s New in v2.8.4: 1. **Multimodal Alt-Text Preservation**: - Visual LLMs need image context! CleanWeb now preserves meaningful descriptive image alt tags (``) while neutralizing sneaky 1x1 tracking pixels. 2. **Zero-Overhead SPA Hydration Parsing**: - Modern Next.js (`__NEXT_DATA__`) and Nuxt.js (`__NUXT_DATA__`) sites are now parsed directly from state payloads in pure Python—saving up to 95% of execution time compared to full headless browser boots. 3. **Official Ecosystem Packages Live on PyPI**: - By popular request, you can now use CleanWeb natively in any framework: - **LangChain**: `pip install langchain-x402-cleanweb` ([PyPI](pypi.org)) - **LlamaIndex**: `pip install llama-index-readers-x402-cleanweb` ([PyPI](pypi.org)) - **Core MCP Server**: `pip install x402-cleanweb-agent==2.8.4` ([PyPI](pypi.org)) --- ### ⚙️ Quick MCP Setup (Claude Desktop / Cursor) Add to your `claude_desktop_config.json`: ```json { "mcpServers": { "cleanweb": { "command": "python", "args": ["-m", "x402_cleanweb_agent.mcp_server"] } } } ``` Includes 5 free zero-configuration trial queries per session nonce. For autonomous agents, native M2M micro-payments (USDC) over Base, Polygon, Arbitrum, and Solana are fully supported. * **GitHub**: nohosa001-pixel/x402-cleanweb-agent Thank you again to this amazing community for pushing the boundaries of autonomous MCP tooling! Let us know what you'd like to see next! 🚀

Top 5 Framework AI Agent di GitHub: crewAI Cuma #3 Ini lima framework AI agent dengan bintang GitHub terbanyak, dihitung hari ini. #1 Langchain — 148.840 bintang (langchain-ai/langchain) #2 Autogen — 61.663 bintang (microsoft/autogen) #3 crewAI — 60.394 bintang (crewAIInc/crewAI) #4 Langgraph — 44.287 bintang (langchain-ai/langgraph) #5 Agno — 43.009 bintang (agno-agi/agno) Empat dari lima pakai lisensi open source. Autogen pengecualiannya. Kamu pakai yang mana? Tulis di komentar 👇 Data: Bintang Github · 2 Nov 2026 #Shorts #AItools #GitHub #opensource #belajarAI #programmer

@titong0 git push al servidor directamente -> 4lb0/vps

Just remember it's an illustration: a.click() draws the click, it doesn't drive your real app. npx skills add benjitaylor/skills --skill stageshow benjitaylor/skills

Nothing dropped on the floor: how every lesson, finding and shortcut got harvested AI-assisted development produces a lot of exhaust. A reviewer flags something out of scope. A workaround goes in "for now". The agent finds a bug in a file it wasn't asked to touch. I correct its approach for the third time. In most projects, that exhaust evaporates. In ParkEase, it had five places to land, and a hook that wouldn't let a task end until it had. Five harvest bins 1. learnings.md: fixes that cost time. Covered in post 6: 246 entries, read before every task. 2. suggestedtask.md: things found and deliberately not done. Every time the agent noticed something worth fixing that would bloat the current change, it added a row: where it was found, why it was deferred, and what "done" means for it. By the end, 162 findings had been logged this way. The rule behind it: > Keeping a task the size it was scoped to be is right; dropping the finding on the floor is not. That one rule ended "I noticed X but didn't mention it", which is where AI-assisted projects quietly rot. Rows get closed later, in batches, by whichever task naturally touches that code. 3. ponytail: comments: shortcuts with a label. When the agent deliberately cut a corner, the code says so, names the ceiling and the upgrade path (post 4). Debt you can grep for isn't hidden debt. 4. Decision records: structural choices. 34 of them. When a tool or a skill gave advice that contradicted a decision, the decision won and the agent had to say so. When a decision changed, it was amended in writing, never silently. 5. Memory: corrections to how the AI works. Claude Code keeps a small per-project memory. Every time I corrected the agent's behaviour, not just its code, that correction became a memory with the reason attached. A few that stuck: - Research first. After it guessed four wrong prop names on a map library one at a time, instead of reading the type definitions once. - Run gates, don't narrate them. After it wrote "Security: raw-body HMAC, amount re-fetched" into a checklist (a description of the code, not a review) and called the review done. - Token budget over ceremony. After about 40 reviewer agents on one task ate most of a week's usage limit. Twelve of the project's memories are behavioural corrections like these. Each one is a mistake that happened exactly once. The hook that enforces it Good intentions don't survive a long session, so harvesting is enforced by a hook: a script that runs whenever the agent tries to finish. If the task was complex (three or more file edits) and none of the learnings, test-case or decision files were touched, the agent isn't allowed to stop. It checks the files' modification times, so intent doesn't count; only a written entry does. The same hook also watches the agent's final message for the classic rationalizations, phrases like "this is a pre-existing issue", "skipping tests for now", or "tests are failing but I'll fix them later". Saying one doesn't end the task; it blocks it. What harvesting bought The second half of the project was noticeably smoother than the first, and it wasn't because the model changed. The repo had learned. Traps that cost an hour in week one cost a four-second read in week four. Review findings didn't vanish. And the agent's worst habits, guessing, narrating, over-dispatching, each got corrected once and stayed corrected. The model forgets everything every session. The project doesn't have to. --- Next (bonus posts): the series continues with stories I didn't plan to tell, starting with being offered 292 skills and installing 21. ParkEase is a peer-to-peer parking marketplace for India, built solo with Claude Code. *Code: Deonkar/parkease*

Your AI coding agent might be wasting tokens without you noticing. Microsoft's TokenEconomizer reports 18–31% lower costs in its benchmarks. Would you install this to reduce your coding-agent bills? microsoft/TokenEconomizer

> Masthead set in Manufacturing Consent I like the description for Manufacturing Consent font: fonts.google.com github.com/google/fonts/blob/main/ofl/manufacturi…