Mentions
Conversations linking to GitHub, newest first. Times are UTC.
Mentions by source
X
Bluesky
Hacker News
V2EX
Qiita
DEV
Mastodon
Latest posts
Here’s the free jailbreak prompt library: togg53192-cmd/jailbreaks Find the file for your model—DeepSeek, GLM, Kimi, Claude, etc.—and follow its setup notes. The files are complete prompts or configurations, ready to copy. Use the system-prompt, custom-instruction or agent-configuration field the file is intended for. Files meant as AGENTS.md belong in the specified project or global instruction location. For the setup above: choose your model in OpenCode, add the matching prompt, then connect REA using its setup process. Restart OpenCode after connecting REA so the tools are available.
Feel free to subscribe to omnidiff#62 to get notified when Lazygit support is added. An extremely thorough comparison against difftastic is in the research/ directory. I don't recommend reading it, unless you are really into diffs. Even describing the dataset takes a good half an hour. Multi-file support is on the roadmap. Subscribe here: omnidiff#63
Looking for Lenovo laptop owners to help test a read-only keyboard backlight compatibility scanner Hi everyone! I'm maintaining an open-source fork of Auto Backlight for ThinkPad, a Windows utility that automatically turns the keyboard backlight on when you start using your laptop and turns it off after a configurable period of inactivity. The application currently works on my ThinkPad X1 Extreme Gen 2 using Lenovo's IBMPmDrv driver. I've also implemented experimental EnergyDrv support, but it hasn't been verified on physical EnergyDrv hardware yet. I'd like to investigate potential compatibility with other Lenovo laptop families, including: - ThinkBook - IdeaPad / IdeaPad Gaming - Yoga / Yoga Slim - Legion - LOQ - Other Lenovo models with backlit keyboards What I'm looking for I've created a small, open-source Lenovo Compatibility Scanner that collects basic information about the keyboard backlight interfaces exposed by your laptop. The scanner checks: - Lenovo laptop model and Windows version - BIOS version (optional) - Presence and state of IBMPmDrv and EnergyDrv driver services - Lenovo-related WMI interfaces, class names and method declarations - Potential Legion and Gamezone lighting interfaces Important: this is a metadata-only scanner, not a hardware compatibility test. It does NOT change your keyboard backlight, execute firmware methods, send driver commands, modify BIOS settings, install drivers or upload anything. No administrator privileges are required. You don't need to install Auto Backlight for ThinkPad or any other application. How to participate 1. Download Scan-LenovoCompatibility.ps1 from the GitHub repository. 2. Open Windows PowerShell normally (not as Administrator). 3. Run the script using the instructions in the scanner README. 4. Review the two locally generated reports: LenovoCompatibilitySummary.txt and LenovoCompatibilityReport.json. 5. Open a compatibility report issue on GitHub and share a reviewed summary. The JSON attachment is entirely optional. The reports contain model and firmware metadata, so please review them and remove anything you don't want to share. Nothing is uploaded automatically. If possible, also mention your exact Lenovo model, whether the keyboard has white or RGB backlighting, whether Fn+Space controls it, and whether you're using Lenovo Vantage, Legion Space or another lighting utility. Links Project: prat89/auto-backlight-for-thinkpad Scanner source: github.com/prat89/auto-backlight-for-thinkpad/blo… Scanner instructions: github.com/prat89/auto-backlight-for-thinkpad/blo… Submit a report: github.com/prat89/auto-backlight-for-thinkpad/iss… Even a report showing no relevant drivers or WMI interfaces is useful. It helps establish which hardware interfaces are present on different Lenovo models and which approaches deserve further investigation. Please note that the current application is not claimed to support all these laptop families, and the scanner does not establish whether the app will work on your device. Thanks to anyone willing to help expand Lenovo compatibility!
Spirals of Threads Max Iter's Fractal Follies for November 2nd, 2010 Roger Alexander's commentary for the image: > > Today's post uses a formula using a Julia iteration loop producing > a spirals of threads design. Ready made at maxitersfractalfollies.blogspot.com > > > > Roger Alexander PAR file Spirals_of_Threads { ; fract492.gif ; blank ; calctime 0:06:08.77 ; created Nov 02, 2010 ; Fractint Version 2004 Patchlevel 10 reset=2004 type=formula formulafile=kerrym.frm formulaname=km_10 center-mag=-0.550248/0.349382/6.884776 params=0.1263771477401044/0.1877803888058107/-0.8391064180425428/0.67070\ 52827539903/0.1497543259987182/0.7999206518753624/-0.749626148258919/0.7\ 06839197973571 float=y maxiter=1500 inside=0 decomp=256 periodicity=0 colors=000000000000000000000000000000000100100200400500700900B00D00G00I0\ 0L00O10Q10T10W10Z10a10e10h20k20o20r20v20y20z30z50z60z80z90zB0zC0zE0zF0zH\ 0zI0zK0zL0zN0zO0zQ0zR0zT0zU0zW0zX0zZ0z_0za0zb0zd0ze0zg0zh0zj0zk0zm0zn0zp\ 0zq0zs0zt0zv0zw0zy0zz1zz3zz4zz6zz7zz7zy7zx7zx7zw7zv7zv7zu7yt7ys7ys7yr7yq\ 6yq6yp6yo6yo6xn6xm6xl6xl6xk6xj6xj6xi5xh5wh5wg5wf5we5we5wd5wc5wc5vb5va5va\ 5v`4v_4vZ4vZ4vY4vX4uX4uW4uV4uV4uU4uT4uS3uS3uR3tQ3tQ3tP3tO3tO3tN3tM3tL3sL\ 3sK3sJ2sJ2sI2sH2sH2sG2sF2rE2rE2rD2rC2rC2rB1rA1rA1r91q81q71q71q61q51q51q4\ 1q31p20p20o20n20m20m20l20k20j20j20i20h20g20g20f20e20d20d20c20b20a20a20`2\ 0_20Z20Z20Y20X20W20W20V20U20T20T20S20R20Q20Q20P20O20N20N20M20L20K20K20J2\ 0I20H20H20G20F20E20E20E20D20D20C20C20C20B20B20A20A20A2092092092082082072\ 0720720620620520520520420420420320320220220220120120010 } frm:km_10 { ; Kerry Mitchell 11may98 ; originally conic-near_juli ; tweaked so user can directly input ; julia parameters (p4) originally hardcoded ; to 0,1 cc=p4, zc=pixel, maxr=1e12, minr=maxr, iter=1 a=real(p1), b=imag(p1), c=real(p2), d=imag(p2) e=real(p3), f=imag(p3): iter=iter+1, zc=sqr(zc)+cc, x=real(zc), y=imag(zc) conic=|x*(a*x+b)+y*(c*y+d)+e*x*y+f| if (conic<minr) minr=conic end if if ((|zc|>maxr)||(iter==maxit)) iter=-1 t=log(minr) z=cos(t)+flip(sin(t)) end if iter>0 } Want to render these yourself and explore further? Try out the PAR file in Iterated Dynamics, an open source fork of FRACTINT that can render these PAR files. See the online help for instructions on using Id or press F1 anywhere in the program for context-sensitive help.
Can a browser FEM solver hit a NAFEMS benchmark? #Shorts NAFEMS T4 thermal benchmark, solved in the browser with FEAScript, an open-source finite element library in JavaScript. NAFEMS target at point E: 18.3 °C FEAScript: 18.26 °C (12 × 20 quadratic mesh, 1,025 nodes) Refining the mesh converges to 18.25 °C. Code: FEAScript/FEAScript-core Website: feascript.com FEAScript isn't affiliated with or endorsed by NAFEMS. #FEA #FiniteElements #JavaScript #Engineering #CAE #OpenSource #Shorts
StarCraft Remastered (PC) | Android Port | Odin 2 Portal Link: nikoltu/open1161HD-android-native
How I ship fixes to open-source projects maintainers actually merge (with AI in the loop) Last month six of my pull requests were merged into other people's projects: an Android keyboard, a Python OAuth library and a reverse-engineering toolkit. Seven more are in review in Hyperledger Besu, Qwen Code, ParadeDB and Ratatui. Rust, Java, TypeScript, Kotlin and Python. I use AI heavily to get there. I also know how maintainers feel about drive-by AI pull requests, because I read their issue threads. So here's the workflow I've settled on: fast because of AI, and still something a maintainer is glad to review. 1. Read the project's rules before the code Every project I contribute to gets the same first pass: CONTRIBUTING.md, any AGENTS.md, the PR template, and the AI policy if there is one. The policies vary a lot. Ratatui welcomes AI-assisted PRs and asks you to say so. pandas wants the human to open the PR and do the talking, and to say which tools were used. Some projects ban AI-generated contributions outright, and I don't contribute to those. Others need a signed CLA or a DCO sign-off on every commit. I keep a small policy file per repo so I never have to rediscover this, and so I never send a PR the project said it doesn't want. 2. Reproduce first, then write the failing test A fix isn't real until a test fails without it. In Ratatui, Japanese halfwidth sound marks (゙ ゚) started taking two cells instead of one. Nothing in Ratatui had changed. The unicode-width crate's 0.2.3 release had corrected those characters from width 0 to width 1, and Ratatui had a workaround that added +1 for them. Both "fixes" were now applying at once. I ran the existing test suite on both dependency versions: everything passed on 0.2.2, and eight tests failed on 0.2.3. That told me the bug was real, where it was, and which tests would prove the fix. 3. Make the smallest change that turns it green .filter(|c| { matches!(*c, '\u{FF9E}' | '\u{FF9F}') && c.width() == Some(0) // only compensate when unicode-width doesn't }) One condition. It's correct on both versions of the dependency, so nobody has to pin anything. I didn't bump the dependency floor, refactor the width code or "clean up" anything nearby. Maintainers review for free, and every extra line is a cost I'd be putting on them. 4. Ask when the fix is a design decision Not every bug has one right answer. In Qwen Code, a /loop that had been told to stop could still resume, because a wakeup that had already fired was sitting in a queue the cancel path couldn't reach. Fixing the queue properly changes behaviour for people who chat while a loop runs. So instead of guessing and sending a large PR, I wrote up what I'd traced, offered three scoped options, and asked which semantics they wanted. A five-paragraph comment costs the maintainer two minutes. A 300-line PR in the wrong direction costs them an hour and a polite rejection. 5. Review my own work like it's someone else's Before anything is pushed I go through it as a reviewer would: - Correctness: edge cases, error paths, callers that might break. - Tests: does each new test fail if the fix is removed (a revert check)? - Security: anything touching input handling, auth or dependencies. - Honesty: the PR text says exactly what the diff does. If it fixes half an issue it says "Refs", not "Fixes", and explains what's left. That last one matters more than it sounds. Two of my Besu PRs this week fix part of an issue and say so. Changing the rest would have broken existing API clients, and that's the maintainers' call to make. Where AI fits AI makes the slow parts fast: searching big codebases, reading unfamiliar modules, drafting tests and first versions of a change, running checks, keeping track of a dozen open PRs. It's also good at finding the issues worth doing. Fresh bugs in popular repos get claimed within hours, so speed of triage matters. What it doesn't do is decide. Which issue is worth my time, whether a fix belongs in the code or the docs, when to stop and ask, what not to change: that's still engineering, and it's still my name on the commit. Where a project asks contributors to disclose AI use, I disclose it. What's next I'm focusing on a few projects where I can become a regular contributor rather than a one-off: Qwen Code on the AI-tooling side, Besu on Ethereum infrastructure, and one more AI infrastructure project. Reviews, bug triage and docs count too. They're some of the most useful work you can give a maintainer. If you maintain a project and have issues that need hands, I'd like to hear about them. John Alexander Kamau, Senior AI & Full-Stack Engineer. github.com/Xander-AJ
GTA2 in 2026: path-traced, HD cars, real glass. Built with Claude Had a lot of fun upgrading gebdag's GTA2 RTX Remix mod. I'm not a programmer, so I built this with Claude/ What it adds: HD car textures with PBR materials, real glass, doors and dents, light improvements, blood puddles and mission voiceovers. The game is still a very solid experience. Free and open source (MIT). Needs your own copy of GTA2, RTX Remix and an RTX card. Download and install steps are in the README: github.com/kirmm3la/gta2-rtx-remix-upgraded/relea…
Karpathy built HackerTube in 2 hours. I rebuilt it in the open and measured it *Inspired by Andrej Karpathy's HackerTube. Live demo: vishalmysore.github.io Hacker News commenters have been sharing YouTube links since 2007. Some of those links are the best talks, lectures and documentaries on the internet: Engelbart's Mother of All Demos, Robert Lustig on sugar, Joel Spolsky on Excel. Most of them are not recommendations at all. They are a music track, a news clip, a joke, a link dropped as evidence in an argument. Karpathy's HackerTube showed that an LLM can sort the two and turn twenty years of comments into a watch list. OpenTube does the same thing and also publishes three numbers that matter if you want to trust the list, or build something like it yourself: 1. How often the filter is right, measured on a labelled random sample. 2. What each step costs, in time and tokens. 3. How the videos connect, as a knowledge graph you can ask questions of, in your browser. The problem: "is this a recommendation?" is a fuzzy question Take two comments that both contain a YouTube link: - "Here is an MIT course, Introduction to CS and Programming. The professor keeps everything simple because the class is for beginners." This is a recommendation. - "[YouTube video]", posted alone under a thread about the Turbo Encabulator. This is not, by the rubric used here: a bare link with no context. People disagree on the cases in between. Out of 300 random comments, 32 were hard enough to be flagged as borderline. If you hand the whole archive to an LLM and publish what comes out, you don't know how good the list is. You also pay for an LLM call on every one of 257,038 comments. The idea: a cheap model first, the LLM only when it is unsure The filter is a cascade of two models. - Laya, a small typed-decision model, reads each comment and gives a probability that it recommends the video. If that probability is clearly high or clearly low, Laya decides on its own. - Qwen2.5-1.5B-Instruct, a small LLM, sees only the comments Laya is unsure about. Both run on a laptop CPU with ONNX Runtime for the batch run, and in the browser for the demo. No API key is needed. What the site does Watch: the canon, filtered !Image description Every Hacker News item from 2006 to 2026 (49 million of them) was scanned for YouTube links. That gives 185,909 distinct videos. 1,345 of them were linked by ten or more different people, and that set is the canon. Each card shows how many people linked the video, the thread it came from, the comment that recommended it, and which model made the call. Receipts: accuracy and cost, in the open !Image description The Receipts page shows the funnel from 49 million items down to the kept videos, the accuracy table, and the cost of each stage at prices you can edit. The thresholds are editable too, so you can see how the trade-off between precision and recall moves. | Filter | Accuracy (cross-validated) | Precision | Recall | Time per comment | Sent to LLM | |---|---|---|---|---|---| | Laya only | 70.8% | 76.9% | 29.1% | 1.28 s | 0% | | Qwen2.5-1.5B only | 67.7% | 59.1% | 50.5% | 4.11 s | 100% | | Cascade | 71.2% | 67.5% | 50.5% | 2.46 s | about 30% | Two results stand out: - The small LLM on its own is worse than Laya and about three times slower. More model is not automatically better on a fuzzy yes/no call. - The cascade is the best of the three and calls the LLM on only about a third of the comments. It keeps the LLM's recall and most of Laya's precision. For a sense of scale, answering "not a recommendation" every time already scores 65.7%. This is a hard call, and a few points of accuracy matter. Projected over all 257,038 comments on this CPU: about 12 days with the LLM on everything, about 6 with the cascade, about 4 with Laya alone. Labels: check the ground truth yourself !Image description All 300 labelled comments are on the Labels page next to the rubric, with each model's probability shown under every comment. If you disagree with a label, change it. The Receipts page re-scores everything with your version, and you can export your labels as JSON. Ask the graph: questions answered from the graph !Image description The videos are linked in a graph: two videos are connected when they were shared in the same HN thread, by the same person, or with similar recommendation text. When you ask a question such as "documentaries about the history of computing": 1. The question is embedded in your browser with MiniLM (about 23 MB). 2. The closest videos become seeds: here, the Mother of All Demos, the Secret History of Silicon Valley, and The Century of the Self. 3. The graph pulls in their neighbours through shared threads, shared commenters and topics (SAGE-style expansion). 4. If your browser has WebGPU, a small LLM writes an answer that cites the videos it used. Without WebGPU you still get the retrieved videos and the graph, as in the screenshot above. Where this is useful - Discovery. A watch list of the talks and documentaries a technical community has kept pointing to for twenty years, grouped by topic. - A template for any LLM filter over a large corpus. Comments, support tickets, reviews, or papers: put a cheap classifier in front, send only the unsure cases to the LLM, and measure both against a labelled sample before you trust the output. - Honest cost planning. Time and tokens per stage, measured, with a projection for the full corpus, so you can decide before you spend. - Private, local Q&A. Retrieval, graph expansion and the answer all run in the browser. Nothing you ask leaves your machine. Limits - The 300 labels are a first pass by one labeller (Claude, following a written rubric). That makes a useful smoke test, not a benchmark. Corrections are welcome. - The thresholds were chosen on the same sample, which is why the cross-validated numbers are shown next to the in-sample ones. - The published canon run is partial: 632 of 2,683 comments, covering 540 of the 1,345 canon videos. The runner resumes where it stopped, and a GitHub Actions workflow is included to run the whole archive month by month. - Video titles are looked up in your browser. The dataset stores only video IDs. Try it - Live demo: vishalmysore.github.io - Code and data: vishalmysore/OpenTube (Apache-2.0) Built on the open-index/hacker-news dataset (ODC-By), Laya typed-decisions, Qwen2.5-1.5B-Instruct via WebLLM, and all-MiniLM-L6-v2. Inspired by Andrej Karpathy's HackerTube; not affiliated with him, Hacker News or YouTube.
Mia's recipe, the version I ran (bf5f945): MiaAI-Lab/GLM-5.3-Flash-EXL3-2x-DGX-Sparks-TensorFold. One tip for the first start: its CUDA extensions build after the memory budget is taken and need 6-8 GiB more, so build them once with no model loaded.
A 763B MoE at "2 Bits": Where the Bytes Really Go in the GSQ-RCO GGUFs, and Why 100% Recovery Sits Inside the Noise TL;DR ISTA's DASLab published GGUF builds of DeepSeek-V4.1-Flash-1017, a 763B-parameter mixture-of-experts model, at 1.75, 2.00 and 2.25 bits per weight. The Hugging Face counter for the repository shows about 2.4 million downloads in ten days, and its card says the 2.00 build keeps 100.0% of the base model's benchmark average. We did not run these files. What we did was read the card, the per-tensor allocation files the authors ship, and the GGUF headers of the actual shards, then recount the bit budget ourselves. Three things came out of it. First, the "2 bit" label covers only the backbone. A separate 196.6B-parameter lookup table called Engram sits outside the budget at 4.5 bits, and it is 44% of the IQ2_XXS download. Counting every stored weight, that build is 2.66 bits per weight, not 2.00. Second, the searched allocation has no simple pattern you could copy by hand: the "IQ2_XXS" build is made mostly of IQ1_M tensors, and which matrix gets more bits flips between builds. Third, the GPQA-Diamond gaps between builds are smaller than the noise of a 198-question test, so "100.0% recovery" is a statement about resolution as much as about quality. !Stacked bars of on-disk size for three builds: routed experts, dense path and the shared Engram tables What exactly was released? The base model is DeepSeek-V4.1-Flash-1017: 763.2B parameters, 384 routed experts per layer with 6 active per token, and a 1M-token context window, according to the card. The quantized repository (ISTA-DASLab/DeepSeek-V4.1-Flash-1017-GSQ-RCO-GGUF) was created on October 23, 2026, last updated October 28, and stood at about 2.4 million downloads and 551 likes when we queried the Hugging Face API on November 2. Two methods from the same lab make the files. GSQ (arXiv 2604.18556) quantizes each tensor at a given type by learning the grid assignment and per-group scales through a Gumbel-Softmax relaxation. RCO (arXiv 2605.00649) then decides which of K quantization types each of N tensors gets, under a total size budget that it enforces exactly by treating the budget as a manifold in logit space. The output is an ordinary GGUF that llama.cpp b11870 (October 25, 2026) or newer can load, because the type chosen per tensor is a standard one such as IQ1_M or IQ2_XS. A uniform Q2 file spends the same bits on a tensor that barely matters and on one that breaks the model if you touch it. A searched file can move bits between them while the average stays fixed. Where do the bytes of a "2-bit" 763B model actually go? The authors ship an allocation file per build that lists the type of all 1,043 tensors. That tells you the types but not the sizes, so we also read the headers of shards 2 to 5 directly with HTTP range requests (the tensor table sits at the start of each file) and computed bytes from the shapes and the standard ggml block layouts. For all three builds our recount lands on the card's own measured figures: 1.7499, 2.0038 and 2.2501 bits per weight over the 551.88B backbone parameters. Here is the check for the 2.00 build: import struct, urllib.request REPO = "https://huggingface.co/ISTA-DASLab/DeepSeek-V4.1-Flash-1017-GSQ-RCO-GGUF/resolve/main/" # ggml type id -> (name, weights per block, bytes per block) TY = {0:("F32",1,4), 8:("Q8_0",32,34), 13:("Q5_K",256,176), 16:("IQ2_XXS",256,66), 17:("IQ2_XS",256,74), 29:("IQ1_M",256,56), 30:("BF16",1,2)} def header(fn, n=4_000_000): req = urllib.request.Request(REPO + fn, headers={"Range": f"bytes=0-{n-1}"}) b = urllib.request.urlopen(req, timeout=120).read() p = 4 def u(f, k): nonlocal p v = struct.unpack_from("<" + f, b, p)[0]; p += k; return v def s(): nonlocal p k = u("Q", 8); v = b[p:p+k].decode(); p += k; return v assert b[:4] == b"GGUF" and u("I", 4) == 3 n_tensors, n_kv = u("Q", 8), u("Q", 8) ints = {2: ("H", 2), 4: ("I", 4), 5: ("i", 4)} for _ in range(n_kv): # shards 2-5 carry only 3 split.* integer keys s(); f, k = ints[u("I", 4)]; u(f, k) out = [] for _ in range(n_tensors): name = s(); dims = [u("Q", 8) for _ in range(u("I", 4))]; ty = u("I", 4); u("Q", 8) out.append((name, dims, ty)) return out tensors = [] for i in range(2, 6): # shard 1 is metadata only, shard 6 is the Engram file tensors += header(f"DeepSeek-V4.1-Flash-1017-GSQ-RCO-IQ2_XXS-0000{i}-of-00006.gguf") def size(dims, ty): n = 1 for d in dims: n *= d name, per, by = TY[ty] return n, n // per * by P = B = Pe = Be = 0 for name, dims, ty in tensors: n, by = size(dims, ty); P += n; B += by if "_exps" in name: Pe += n; Be += by print(f"tensors {len(tensors)} params {P/1e9:.3f}B bytes {B/1e9:.2f} GB bpw {B*8/P:.4f}") print(f"experts: {Pe/P:.1%} of params, {Be/B:.1%} of bytes, {Be*8/Pe:.4f} bpw") print(f"dense path: {(P-Pe)/1e9:.2f}B params, {(B-Be)/1e9:.2f} GB, {(B-Be)*8/(P-Pe):.3f} bpw") It prints: tensors 1042 params 551.881B bytes 138.23 GB bpw 2.0038 experts: 98.5% of params, 95.5% of bytes, 1.9438 bpw dense path: 8.30B params, 6.16 GB, 5.938 bpw The routed experts are 98.5% of the backbone's parameters and 95.5% of its bytes, at 1.94 bits. The dense path (attention, shared experts, output head, embeddings) is only 8.30B parameters, 1.5%, but it is kept at 5.94 bits on average, mostly Q5_K, with the attention KV and query-down projections at Q8_0, and that costs 6.16 GB. So the non-expert part of the model is paid for at roughly three times the expert rate. That is a sensible trade, since every token passes through all of it, and a uniform scheme cannot make it. Then there is the part that is outside the search entirely. The shared Engram file holds one tensor, per_layer_token_embd, with shape 256 by 768,022,850. That is 196.6B parameters stored at IQ4_NL (4.5 bits), 110.6 GB, identical in every build. The card states this plainly: the bit-width quoted is "over the backbone (all tensors except the Engram table)". It is a reasonable definition, since the table is read one row per token. But if you are sizing a disk or a download, the number that matters is different: | Build | Quoted bpw (backbone) | Backbone GB | Engram GB | Download GB | Bits per weight over both parts | Engram share of bytes | |---|---|---|---|---|---|---| | IQ1_M | 1.75 | 120.72 | 110.60 | 231.32 | 2.47 | 47.8% | | IQ2_XXS | 2.00 | 138.24 | 110.60 | 248.84 | 2.66 | 44.4% | | IQ2_XS | 2.25 | 155.23 | 110.60 | 265.83 | 2.84 | 41.6% | The two parts we can read add up to 748.5B parameters out of the 763.2B the card quotes for the base model. We did not try to account for the remaining 14.7B. Does the search follow a rule you could apply by hand? We went looking for one, because a rule would let you quantize your own MoE without the search. The allocation files do not offer one. Start with the labels. In the IQ2_XXS build, 60 of the 120 routed-expert tensors (40 layers times gate, up and down) are IQ1_M, 42 are IQ2_XXS and 18 are IQ2_XS. The 2.00 average comes from a mix that is mostly below 2 bits. In the IQ1_M build, 83 of 120 expert tensors are IQ1_S, the 1.5625-bit type. The build name is the budget the search was given, not the type most tensors ended up with. Depth shows a tendency, not a law. In the 2.00 build the first ten layers average 1.77 bits in the experts and the last ten average 2.05. The IQ1_M build leans the same way (1.63 against 1.71). The IQ2_XS build does not: its four groups of ten layers average 2.10, 2.19, 2.30 and 2.19, so the peak is in the middle. Matrix type is the clearest case against hand rules. In the 2.00 build the down projection gets fewer bits than gate and up (1.87 against 1.98). In the 2.25 build it gets more (2.28 against 2.15). Gate and up share the same type in all 40 layers of all three builds, which could be a constraint of how the search was set up or something the search learned. The card does not say which. !Line chart of average routed-expert bits per weight for layers 0-9, 10-19, 20-29 and 30-39, for the three builds The practical reading is that the allocation depends on the budget, and so on the task loss the search sees, rather than on a fixed sensitivity ordering of layers. If you copy "early layers get fewer bits" into your own pipeline, you are copying a tendency from one model at one budget. Is "100.0% recovery" a real result? The card measures three benchmarks at reasoning effort 50 and reports the task average against the base model: | Variant | bpw | AIME25 | GPQA-Diamond | LiveCodeBench v6 | Task avg | Recovery | |---|---|---|---|---|---|---| | Base (FP8 dense, FP4 experts) | n/a | 100.00 | 90.91 | 89.71 | 93.54 | 100.0% | | GSQ-RCO IQ1_M | 1.75 | 100.00 | 88.38 | 88.57 | 92.32 | 98.7% | | GSQ-RCO IQ2_XXS | 2.00 | 100.00 | 90.91 | 89.71 | 93.54 | 100.0% | | GSQ-RCO IQ2_XS | 2.25 | 100.00 | 90.40 | 89.71 | 93.37 | 99.8% | The averages and recovery percentages recompute correctly from the columns. What the table cannot tell you is how much those columns move on a rerun, and two features matter. AIME25 is saturated. The base model scores 100.00 on a 30-problem set, so every build that also scores 100.00 shows only that the test has no headroom. It cannot reveal damage. GPQA-Diamond has 198 questions, so each question is 0.505 points, and the percentages in the table are whole-question counts: 180/198 for the base and IQ2_XXS, 179/198 for IQ2_XS and 175/198 for IQ1_M. The 95% Wilson intervals are 86.1 to 94.2, 85.5 to 93.8 and 83.2 to 92.1. They overlap almost completely. !Horizontal bars showing the 95% Wilson interval of GPQA-Diamond accuracy for the base model and three builds The sharpest case is the largest gap, base against IQ1_M, five questions out of 198. Even if all five discordant questions went the same direction, which is the best case for significance, an exact McNemar test gives p = 0.0625. One question going back the other way (six against one) gives p = 0.125. The card does not publish per-question results, so the real paired test cannot be run, but the best case already fails the usual 0.05 bar. Note also that IQ2_XS (more bits) scores one question below IQ2_XXS. That is what noise looks like, and it is not a defect in the method. import math from math import comb def wilson(k, n, z=1.96): p = k / n; d = 1 + z * z / n c = (p + z * z / (2 * n)) / d h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / d return 100 * (c - h), 100 * (c + h) def mcnemar_exact(b, c): # two-sided exact test on discordant pairs n = b + c return min(1.0, 2 * sum(comb(n, i) for i in range(min(b, c) + 1)) / 2 ** n) for name, k in [("base/IQ2_XXS", 180), ("IQ2_XS", 179), ("IQ1_M", 175)]: lo, hi = wilson(k, 198) print(f"{name:13s} {k}/198 = {100*k/198:.2f}% 95% CI {lo:.1f} to {hi:.1f}") print("best case, 5 questions all in one direction: p =", mcnemar_exact(5, 0)) print("one flip back the other way (b=6, c=1): p =", round(mcnemar_exact(6, 1), 4)) base/IQ2_XXS 180/198 = 90.91% 95% CI 86.1 to 94.2 IQ2_XS 179/198 = 90.40% 95% CI 85.5 to 93.8 IQ1_M 175/198 = 88.38% 95% CI 83.2 to 92.1 best case, 5 questions all in one direction: p = 0.0625 one flip back the other way (b=6, c=1): p = 0.125 None of this says the quantization is bad. The 2.00 build matching the base score on all three benchmarks, down to the hundredth on LiveCodeBench, is encouraging. It says the test is too coarse to rank these builds, and that a "98.7% against 100.0%" gap should not drive a decision. The card also does not state how many samples were drawn per question or the decoding seed, which matters for a model that is run at a reasoning effort setting. Can this really run on a 12 GB GPU? The card says each build runs on a single 12 GB GPU with the Strata engine, with the rest of the model in system memory and the Engram file kept on an SSD. It does not give a system-RAM requirement or a tokens-per-second figure, so here is the arithmetic you would do before buying hardware. From the shapes we can compute what one token has to read. With 6 of 384 experts active per layer, the routed experts contribute 6/384 of 132.07 GB, which is 2.06 GB per token for the 2.00 build. The dense path adds 5.70 GB (excluding the token embedding, which is a single-row lookup). The Engram table adds one row. So the dense path (6.16 GB stored) can sit in 12 GB of VRAM with some room for the KV cache, and the 132 GB of experts cannot. They live in system RAM, or get paged from SSD through memory mapping. The card does not say how Strata places tensors, so this is our assumption about the likely arrangement, not a description of the engine. Under it, the speed limit is how fast 2.06 GB can reach the GPU each token. The numbers below are illustrative ceilings that assume all six experts in every layer are fetched cold, with no expert caching and no overlap with compute: | Link used for the experts | Assumed throughput | Time for 2.06 GB | Ceiling | |---|---|---|---| | PCIe 4.0 x16 from RAM | 25 GB/s | 83 ms | about 12 tokens/s | | PCIe 3.0 x16 from RAM | 12 GB/s | 172 ms | about 5.8 tokens/s | | NVMe SSD, sequential | 7 GB/s | 295 ms | about 3.4 tokens/s | Real throughput will differ. Routing is not uniform, so popular experts can be cached, and transfers can overlap with compute, which raises the ceiling. Small random reads from an SSD run well below sequential speed, which lowers it. The point of the table is the order of magnitude: "runs on 12 GB" and "runs at a speed you would want to chat at" are different claims, and the first is only the memory side of it. It is the same bandwidth-bound logic as sparse models on CPUs, stretched across a PCIe link. What should you do before shipping a build like this? Report bits per weight over everything you store, not only over the part that was searched. For this release that is 2.66 against 2.00, a difference big enough to change a hardware plan. Read the allocation file, or parse the headers as above. It takes minutes and shows which tensors the search protected, here the dense path at about 5.9 bits. Run your own task, with paired per-item results. If two builds differ by a handful of items on a few hundred, you cannot rank them, and a paired exact test tells you that in one line. If your task is long-form or agentic, a 198-question multiple-choice score says little about it. Measure the whole chain on your hardware: load time, first-token latency with a cold expert cache, sustained tokens per second at your context length, and disk wear if you page from SSD. Then pin the runtime: the card's files use the llama.cpp layout from October 27 onward, the Engram file must be linked as shard 6 of each build, and older downloads need the authors' converter script. FAQ What is GSQ-RCO? It is a two-step quantization recipe from the Institute of Science and Technology Austria. GSQ quantizes each tensor accurately at a chosen type, and RCO chooses the type for every tensor under an exact total size budget. The result is a standard GGUF file. Does "2.00 bpw" mean the download is 2 bits per weight? No. The figure is measured over the 551.9B backbone parameters only. The 196.6B-parameter Engram table is stored at 4.5 bits in every build, so the IQ2_XXS download of 248.84 GB works out to about 2.66 bits per weight over both parts. Which llama.cpp version do I need? The card requires b11870 (October 25, 2026) or newer, and the files have used llama.cpp's own DeepSeek-V4.1 layout since October 27. Earlier downloads can be converted locally with the script in the repository. Is the IQ2_XXS build really lossless? Its scores match the base model on all three benchmarks, but two of those benchmarks are small or saturated. On GPQA-Diamond, one question is 0.5 points and the 95% interval is about plus or minus 4 points, so the evidence supports "no large loss on these tests", not "identical". Can I run it on a 12 GB GPU? The card says yes with Strata, with the experts in system memory and the Engram file on SSD. You need roughly 132 GB for the experts plus the dense path, and speed is bounded by moving about 2 GB of expert weights per token. Further reading - Why a Sparse 35B MoE Runs Faster on a CPU Than a Dense 27B Model - 0.1 Bits Per Weight Is Not 0.1 Bits Per Weight: Where the Bytes Go in Sub-2-Bit LLMs Sources: ISTA-DASLab/DeepSeek-V4.1-Flash-1017-GSQ-RCO-GGUF model card and allocation files, GSQ, arXiv 2604.18556, RCO, arXiv 2605.00649, llama.cpp release b11870. Byte counts, bit-widths and statistics above are our own recomputation from the published headers and card; throughput ceilings are illustrative arithmetic, not measurements.
I completed the first transparent post-quantum Zcash transaction on a devnet with zdn, zcash-tpq and SLH-DSA-B-128s! Tested v5 payment, v6 payment, payment from a restored wallet and more Use START-TPQ.md in zdn to try it! jonwalch/zcash-tpq jonwalch/zdn
StarCraft Remastered (PC) | Android Port | Odin 2 Portal Link: nikoltu/open1161HD-android-native
Youssef-joe/SoldierDB هنا في الريبو دي انا بداتها كتطبيق للكتاب ده وعشان عايز اطبق مفاهيم ال DBMSs ال بحاول اذاكرها من مصادر مختلفه زي الكتاب ده وكتاب DB internals وCMU ومصادر لل vector DBs عشان بتشد انتباهي كتير.. المهم اني فاتحها لاي حد حابب يشارك ونطبق المفاهيم سوا t.co
Metal Gear Solid 2 HD (Shield TV) | Android Port | Odin 2 Portal Link: luisxl15/METAL-GEAR-SOLID-2-Sons-of-Liberty-for-Android
Craft Anything rebuilds any website, app or game as your own version. Point it at a target, describe what you want, and it studies the original and builds a new project. Note: early alpha, and building needs your own Claude Code sign-in. GitHub: storytold/craft-anything
Metal Gear Solid 2 HD (Shield TV) | Android Port | Odin 2 Portal Link: luisxl15/METAL-GEAR-SOLID-2-Sons-of-Liberty-for-Android
WrenAI GitHub Explained: Governed Semantic Layers for Text-to-SQL WrenAI by Canner: Canner/WrenAI WrenAI is an open-source context layer for natural-language analytics. This overview explains why raw enterprise schemas can leave business definitions implicit, then follows an invented sales dataset in local DuckDB. It covers MDL version 5 YAML models, calculated net order value, explicit customer relationships, status rules, and omitted columns; compilation into a canonical manifest; LanceDB memory indexing; semantic SQL planning, CTE expansion, and dialect translation; and pre-aggregated cubes. It closes with the trade-off between governed consistency and open-ended exploration, equality-join boundaries, model maintenance, and the repository's path-based licensing structure. TimeStamps: 0:00 Text-to-SQL Accuracy on Enterprise Schemas 1:50 Metric Drift and Business Context 2:38 Local DuckDB Sales Dataset 4:07 MDL Models and Calculated Metrics 5:24 Manifest Compilation and LanceDB Memory 5:45 Semantic Context for a Revenue Query 6:23 Query Parsing and CTE Expansion 7:26 Dialect Translation and Results 8:00 Pre-Aggregated Cubes for Structured Queries 8:52 Governance Trade-Offs and Equality Joins 9:38 Licensing and the Compiler Design Takeaway 🧠 Governed semantic context for AI-assisted analytics 🗂️ MDL models define metrics, joins, and visible fields 🧩 Query planning expands semantic SQL into database dialects 📊 Cubes structure recurring analytical aggregations WrenAI's semantic layer is most useful when metrics, joins, and business rules need a shared definition across AI-assisted analytics. The key trade-off is explicit: more governed context and auditability require more modeling and maintenance, while unmodeled questions remain outside the defined surface. #WrenAI #TextToSQL #DataEngineering [de-DE] YNAS ynp_eedcf555c33b00ca Cinematic Privater automatisierter Staging-Upload. Paketidentität: ynp_eedcf555c33b00ca; Ausgabe: cinematic. [es-US] YNAS ynp_eedcf555c33b00ca cinemático Carga de entorno de prueba de automatización privada. Identidad del paquete: ynp_eedcf555c33b00ca; salida: cinematográfica. [fr-FR] YNAS ynp_eedcf555c33b00ca cinématique Téléchargement de l'environnement de test d'automatisation privé. Identifiant du package : ynp_eedcf555c33b00ca ; sortie : cinématique. [hi] YNAS ynp_eedcf555c33b00ca सिनेमैटिक निजी स्वचालन स्टेजिंग अपलोड। पैकेज पहचान: ynp_eedcf555c33b00ca; आउटपुट: सिनेमाई। [id] YNAS ynp_eedcf555c33b00ca sinematik Unggahan staging otomatisasi pribadi. Identitas paket: ynp_eedcf555c33b00ca; output: sinematik. [it] YNAS ynp_eedcf555c33b00ca cinematic Caricamento di automazione privata. Identità del pacchetto: ynp_eedcf555c33b00ca; output: cinematico. [pt-BR] YNAS ynp_eedcf555c33b00ca cinematográfico Upload de teste de automação privada. Identificação do pacote: ynp_eedcf555c33b00ca; saída: cinemática.
@tpm_28 how does this compete with Hop (Arjun-Ingole/hop) ?
My 11 yr old has become that super tech oriented friend I send new cool things to play with. We built a complete Minecraft server over SSH this weekend and I already sent him yc-software/minecraft-agent-harness to hack on next one.
Looking forward to more challenges as I progress. #CodingJourney #DSA #programming #javascriptprojects github.com/JonathanDaivdE/freecodecamp-projects/t…
@motoki_8strings 初めまして。lightroom-cliを使わせて貰っているのですが、Generating Previewのプログレスバーが残り続ける問題がありそうなのでPRを出してみました。お手すきの際に確認して貰えると嬉しいです。 lightroom-cli#4
@hnhnmhjpaperbag @Arifutatsu I gotchu: 26d0/shtts-web
Show HN: Vaire, Self-Hosting Postgres Through the One Glorious CLI
How I Built a Shift-Left DevSecOps Pipeline for FastAPI & Kubernetes (And Caught 3 Real High-Severity CVEs with Trivy) published: true When an e-commerce platform runs a flash sale, traffic can jump from 10 requests per second to 10,000 in under a minute. If your team hasn't tested how your containers and Kubernetes pods behave under a sudden traffic surge—or how Kubernetes self-heals when a pod returns HTTP 503—production is the worst place to find out. Even before code reaches a Kubernetes cluster, there is a second problem: most CI pipelines only check if the code runs, not if the container image is secure. Warning-only security scans get ignored, leaked secrets hide in Git commit history, and default base images quietly ship with unpatched vulnerabilities. To solve both problems, I built CloudPulse—a two-repository High-Availability Cloud Status & Incident Telemetry Platform designed around strict shift-left DevSecOps gates and GitOps delivery: - Part 1 (App & DevSecOps CI): cloudpulse-devsecops-service — FastAPI telemetry & chaos microservice, multistage Docker hardening, and a 3-stage GitHub Actions pipeline. - Part 2 (AWS EKS & GitOps Infra): cloudpulse-eks-gitops-infra — Modular AWS VPC & EKS Terraform IaC, Argo CD GitOps continuous delivery, Kubernetes HPA auto-scaling, and Prometheus/Grafana observability. Here is how I architected the pipeline, how our Trivy security gate blocked a real build after catching 3 HIGH severity CVEs, and how I remediated them to reach a zero-CVE container build. --- 1. Designing a Microservice Built for Kubernetes Chaos Testing Instead of deploying a static "Hello World" container, CloudPulse exposes real Prometheus telemetry (cloudpulse_http_requests_total, cloudpulse_flash_surge_events_total, cloudpulse_service_health_status, and request latency histograms) alongside two interactive chaos endpoints: 1. POST /simulate-surge: Launches a non-blocking 30-second background task (asyncio.create_task) that injects synthetic checkout traffic bursts into the Prometheus counters to trigger downstream Kubernetes HorizontalPodAutoscaler (HPA) scaling and Grafana alerts. 2. POST /simulate-outage: Flips the internal service health state so GET /healthz returns HTTP 503 Service Unavailable, allowing us to test Kubernetes Liveness and Readiness probe self-healing in real time. Baseline Healthy State (200 OK) !CloudPulse Healthy Dashboard Active Flash-Sale Traffic Surge !CloudPulse Flash Surge Active Simulated Server Outage (503 OUTAGE) !CloudPulse Outage Simulation --- 2. The 3-Stage Shift-Left DevSecOps Pipeline Every push and pull request to main passes through three strict gates in .github/workflows/devsecops.yml before any container image can be published to GitHub Container Registry (ghcr.io). 1. Station 1 — Code Quality & Unit Tests (Ruff + Pytest): Lints Python syntax/import formatting and executes automated TestClient tests verifying /healthz, /metrics, surge increments, and 200 <-> 503 outage toggling. 2. Station 2 — Full-History Secret Scanning (Gitleaks): Runs gitleaks-action@v2 with fetch-depth: 0 to scan the entire Git commit history—not just the latest commit—so accidentally committed AWS keys or tokens block the build immediately. 3. Station 3 — Multistage Container Build, Trivy CVE Gate & Smoke Test: Builds the production Docker image, scans both OS packages and Python libraries with Trivy (exit-code: '1', severity: 'CRITICAL,HIGH'), spins up the live container to smoke-test /healthz and /metrics via curl --fail, and pushes to ghcr.io. --- 3. Real-World Remediation: When Trivy Blocked the Pipeline Having exit-code: '1' configured on Trivy immediately proved its value on our initial pipeline run. Even though our code passed all unit tests and used the official python:3.12-slim base image, Trivy failed the build and blocked the image from publishing after detecting three actionable HIGH severity vulnerabilities and vulnerable vendored SBOM metadata: | CVE ID | Package | Vulnerability Summary | Fixed Version | | :--- | :--- | :--- | :--- | | CVE-2025-62727 | starlette | DoS via Range header merging | 0.49.1 | | CVE-2026-48818 | starlette | SSRF / NTLM credential theft in StaticFiles | 1.1.0 | | CVE-2026-54283 | starlette | request.form() limits bypassed enabling DoS | 1.3.1 | Additionally, Trivy flagged embedded CycloneDX SBOM files (bom.cdx.json) bundled inside setuptools and wheel in the base Python image that referenced older vulnerable package versions. How We Fixed It for a 0-CVE Build First, we pinned starlette>=1.3.1 alongside upgraded fastapi in requirements.txt so transitive dependencies could no longer resolve to vulnerable versions. Second, we hardened our multistage Dockerfile to patch OS packages, strip unused packaging tools and embedded bom.cdx.json metadata from the runtime image, and execute Uvicorn under a locked-down non-root user (appuser, UID 10001): # Stage 1: Builder FROM python:3.12-slim AS builder WORKDIR /build RUN python -m venv /opt/venv ENV PATH="/opt/venv/bin:$PATH" COPY requirements.txt . RUN pip install --no-cache-dir --upgrade pip setuptools wheel && \ pip install --no-cache-dir -r requirements.txt && \ find /opt/venv -name "bom.cdx.json" -delete # Stage 2: Hardened Runtime FROM python:3.12-slim AS runtime RUN apt-get update && \ apt-get upgrade -y && \ apt-get install -y --no-install-recommends curl && \ rm -rf /var/lib/apt/lists/* && \ pip install --no-cache-dir --upgrade pip setuptools wheel && \ rm -rf /usr/local/lib/python3.12/site-packages/setuptools* \ /usr/local/lib/python3.12/site-packages/wheel* && \ find /usr/local/lib/python3.12 -name "bom.cdx.json" -delete RUN groupadd -g 10001 appuser && \ useradd -u 10001 -g appuser -s /sbin/nologin -M appuser WORKDIR /app COPY --from=builder /opt/venv /opt/venv COPY --chown=appuser:appuser app/ ./app/ ENV PATH="/opt/venv/bin:$PATH" \ PYTHONDONTWRITEBYTECODE=1 \ PYTHONUNBUFFERED=1 USER appuser EXPOSE 8000 HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \ CMD curl -f http://localhost:8000/healthz || exit 1 CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"] On the next push (commit 688dfa7), Trivy reported 0 HIGH or CRITICAL vulnerabilities, the container smoke tests passed, and the verified image was published to ghcr.io. --- 4. Downstream GitOps Delivery & Observability (Preview of Part 2) Because we separated our application repository from our infrastructure repository following enterprise GitOps practices, our second repository cloudpulse-eks-gitops-infra provisions the AWS VPC & EKS architecture with Terraform and uses Argo CD (selfHeal: true, prune: true) to deploy the verified container. When we trigger the Flash-Sale Traffic Surge across the Kubernetes pods, Prometheus scrapes the /metrics endpoint and Grafana visualizes the real-time request spike (~300 req/s) and pod readiness. --- Explore the Full Source Code Both repositories—including the FastAPI source, unit tests, multistage Dockerfile, GitHub Actions workflows, AWS EKS Terraform modules, Argo CD manifests, and Grafana dashboard JSON—are open source on GitHub. - Part 1 (App & DevSecOps CI/CD): cloudpulse-devsecops-service - Part 2 (AWS EKS Terraform, Argo CD & Observability): cloudpulse-eks-gitops-infra
i found a Google Research repo tonight, Harness². instead of fine-tuning the model, it edits the harness itself (prompts, tools, skills) mid-task, keeping what works for next time. real gains on GLM-5 and Gemini 3.5 Flash. i haven't run it myself. google-research/harness2 t.co
@67loonaphonk @Arifutatsu Found it: 26d0/shtts-web
仓库:tt-a1i/archify 官网:archify.si 图廊演示:archify.si Release v3.2.0:github.com/tt-a1i/archify/releases/tag/v3.2.0 https://skills.sh:https://skills.sh/tt-a1i/archify/archify
Va de maravilla, es literalmente lo que debió haber sido Siri: anomalyco/hex
openidea - free open source tool OpenIDEA is a free IDE that delivers the familiar IntelliJ IDEA workflow in a native Rust application. Free and open source. Comment Openidea and I'll send you the link. l0ng-ai/openidea #opensource #github #ai #devtools #codeeditor #crossplatform #dap #databaseclient More drops like this → repodrop.pages.dev
PocketSDR#99 taroz先生のPocket SDRへのPR。捕捉時間がなんとほぼ半分になる 。 DFTの性質によって、搬送波除去してDFTした結果を、別のドップラービンで使い回せるというもの。これにより、各PRNのFFTについて、DFTが1回と各ドップラービンのIDFTでのみで済む。 # 101のNEONの高速化と
ComfyUIのリポジトリ、PRやIssueたまりすぎてコミュニティとして終わっているww github.com/Comfy-Org/ComfyUI/pulls
Metol updated AGPL-3.0: WApaperplane/metol Two updates worth posting about. Two looks at once, each with its own strength Previously there was a single crossfade ratio: A at 30% meant B at 70%, the two numbers were tied together. Now A and B each have their own 0–100 strength, so 60/25 is a valid combination, and so is100/100. The interesting part is what happens at 100/100. There are three reasonable ways to combine two looks, and two of them produce visibly broken output at full strength — one crushes blacks and clips highlights across a meaningful chunk of the colour cube, the other changes the picture depending on which order you assign A and B (7 levels on average, ~30 at full strength). I ran all 68 shipped tables pairwise to make sure the third approach holds up: no clipping, order-independent, both sliders can sit at 100. I’m not going to claim this is clever — it’s the only one of the three that doesn’t have an obvious failure mode. The useful bit is knowing that “two LUTs with independent opacity” forces that choice whether you think about it or not. All 16 hardware keys work (I previously said they didn’t) In October I wrote down that the NX500’s arrow keys and both dials send no key events, and built a touch-only interaction model around that. That was wrong. I had probed with a 1×1 override-redirect window so it wouldn’t cover the live view; without a window manager, keys go only to the window holding input focus, and that window type never gets it. I measured “I failed to take focus” and recorded it as “the hardware doesn’t send this key.” When the panel itself takes focus, all 16 keys show up — four-way pad, OK, MENU, BACK, play, Fn, and both dials. The dials matter more than the buttons: they emit one key press per detent, not wheel events. That means they work as continuous adjusters. I use the EV dial for paging and the top-right dial for blending strength, one step per detent. The takeaway generalises past this camera: “X11 never delivered key K” and “key K never reached X11” are different claims, and the first one requires proving who held focus first.
🚨 PoC/exploit released for CVE-2026-81963, a Windows Update Stack link-following flaw that lets an authorized local attacker elevate privileges. Affects Windows 11 23H2–26H1 and Server 2025. exploitgrid.net PoC: dis0rder0x00/trustedhive #Windows #CyberSecurity
躺沙发上用手机指挥电脑里的AI写代码,这个我是真馋。 T3 Code,开源免费MIT,把Claude Code、Codex、Cursor、Grok Build这些装好的agent收进一个界面,桌面、网页、手机App都能控。不卖模型,用你自己的订阅。 pingdotgg/t3code 排队买奶茶的时候让AI跑活,你们会这么用吗? t.co
Mediroute: An open-source AI platform exposing global drug price disparities
DeepSeek's R1 weights are MIT licensed, so distilled 7B/14B models run in Ollama or llama.cpp on a consumer GPU. DeepSeek reports R1 matching o1 on AIME 2024 and MATH-500. You can read the reasoning, not just the answer. deepseek-ai/DeepSeek-R1
This FREE AI Agent Hunts Jobs for You Every Day 🤖 Someone built a free, open-source AI agent that runs your job hunt for you 🤖💼 What it does: ✅ Tracks every job application in one place ✅ Builds a resume for each role ✅ Shows your full job funnel, including newly posted jobs ✅ Lets you assign agents that run every single day ✅ Has an MCP option, so you can connect it to Claude or ChatGPT How to set it up: 1. Clone the repo on your computer 2. Add an OpenRouter API key (builds the resumes) 3. Add a RapidAPI key (pulls job listings) That's it. 🔗 Repo link: AienTech/dossier Note: the tool is free. The API keys are pay-as-you-go, so costs depend on how much you use them. 💬 Drop your questions in the comments 🔔 Subscribe for more AI tools that save you hours #shorts #jobsearch #aitools #aiagents #jobhunting #claudeai #chatgpt #mcp #opensource #careertips
Ninja Gaiden Black (Xbox) | Android Port | Odin 2 Portal Link: gamboozino/ngbrecomp
I did this for fun, and it is definitely not a good portfolio to get a job as a C programmer. I was a bit tired of reading some toys made with NextJS+Tailwind CSS+Ugly Glossy Theme+Redis docker image, so I just thought that I can write something else for my toy projects like my dev blog. Anyway, now let's see "why it's simple?" It's an example from CWIST's readme: #include <cwist/app.h> static void hello(cwist_http_request *req, cwist_http_response *res) { (void)req; cwist_sstring_assign(res->body, "Hello from CWIST!"); } int main(void) { cwist_app *app = cwist_app_create(); cwist_app_get(app, "/", hello); cwist_app_listen(app, 8080); cwist_app_destroy(app); return 0; } Some would say it's not that simple. They may say this: #include <cwist.h> static void hello(cwist_http_app *app) { cwist_sstring_assign(app->res->body, "Hello from CWIST!"); } static void setApp(cwist_http_app *app) { CWIST_APP_CREATE(app); app->get.append(app->get, "/", hello); app->ipv4.port = 8080; } int main(void) { CWIST_APP_LISTEN(app); CWIST_APP_DESTROY(app); } Yeah, it looks reasonable at a glance. And this definitely has its own strength. But, some parts are set up by struct members. some are not. some are in ALL CAPS, and some are not. Also, header amalgamation can be easily done by some scripts. Well, in my opinion unifying 'conventions' as many as I can would be a good solution for simplifying code. When somebody vibe-codes an application without looking at their code (although it's a really bad habit but I've seen somebody who does it) hallucinations are more frequently happened from struct members. However public functions seems quite good to be probabilistically inferenced. Also, the second one needs more "helper codes". Formally, yep, CWIST's main is kinda bloated, but each step specified in the main function is executed by an explicit wrapper function. It's just like making a lego building. I know it's not like Drogon. There are really many "mature" C/C++ web frameworks like Drogon, and when you are doing things for production, you cannot use this framework since it's not measured and monitored by security professionals. Each change should pass sanitizers, cppcheck, http soak test, https c100k test, wasm/wasi smoke test, http/2 test, and so on. Actually I thought that I should do something for http/3, but it's just borrowing many things from lsquic so I just didn't do it. It's in this external benchmark: web-frameworks-benchmark.netlify.app Although it's not "blazingly fast C web framework other than CGI", its performance is fair for developing some small websites. And I am pretty sure it will give you a new perspective to see your code as a "well-structured building". C4Punks is an organization with many people but some members are quite busy to co-maintain this, so currently I am mainly checking its status. But it's quite hard to read all those modules and refactor, sometimes I couldn't sleep before releasing a new tag. Any pull requests (including documentations) are welcomed: github.com/c4punks/CWIST/issues Thanks for reading yall.
Brindille, voix de synthèse française, open source, qui tient dans 2,7 Mo Petite expérimentation du weekend : une voix française de moins de 100k de paramètres, la page de démo entière pèse 2,7 Mo, prononciation et moteur d'inférence compris, et tout tourne directement dans le navigateur. Sur un seul coeur de mon Mac l'audio est généré environ 75 fois plus vite que le temps réel. Le moteur est celui d'Alkove, mon projet open source de modèles vocaux. Brindille est sous Apache-2.0. C'est une première tentative, il n'y a qu'une seule voix, le son reste un peu métallique et étouffé, et il y a quelques erreurs de prononciation (on entend que c'est un tout petit modèle). Qu'en pensez-vous ? Hésitez-pas à remonter les défauts que vous repérez ☺️ Démo : huggingface.co Alkove : alkove-ai/alkove
Ever lose track of what's inside your Gaussian Splatting PLY files? I do. So I made SplatThumb: thumbnails for 3DGS .ply files right in Windows File Explorer. You can even set the camera angle per file. Free and open source. VoxelKei/SplatThumb #GaussianSplatting #3DGS t.co
【のだめカンタービレ】DVD #388 everyday-use-git#388 Lesson3の00:30:00~ 今日はのだめDVDの視聴のみ。
LadybugDB/bugscope You can use this to navigate wikidata graph (90m node, 750m edges)
It also reviews pull requests. It leaves its comments on GitHub as a draft, and you read, edit and send them yourself. Free, MIT license: z4forzubair/daily-review
Improved FusionCMS for your wow private server MMO-Coin/FusionCMS
@honjo_yosage Hi I'm a Full-stack software engineer with experience building web and mobile applications across both frontend and backend systems. Proficient in TypeScript, JavaScript, React, Next.js, React Native, NestJS, and Laravel. Here's my github github.com/Jeccoman
Free and open source (MIT): sjgant80-hub/kar-conform As an agent skill: skillhq.dev