Mentions
Conversations linking to GitHub, newest first. Times are UTC.
Mentions by source
X
Bluesky
Hacker News
V2EX
Qiita
DEV
Mastodon
Latest posts
LlamaIndex Workflows vs LangGraph: Event-Driven Architecture and Async State Overhead Showdown LlamaIndex Workflows and LangGraph represent the two dominant paradigms for orchestrating complex agentic swarms: pure event-driven asynchronous message passing versus stateful directed acyclic graph (DAG) state machines. In production multi-agent systems, selecting between these two architectures determines your system's p99 latency profile, state recovery ergonomics, and memory utilization under high concurrency. By benchmarking both frameworks across 500 multi-branch execution tasks at SaaSNext, we discovered that while LangGraph offers superior relational checkpointer persistence, LlamaIndex Workflows cuts dispatch latency by 58% on complex branching paths. - Core Mechanism: Event-driven typed queue dispatching (LlamaIndex) versus compiled Pregel graph state machines (LangGraph). - Hardware & Runtime: Python 3.12, LlamaIndex Core v0.12+, LangGraph v0.2.35+, PostgreSQL 16, and Asyncio. - Production Value: LlamaIndex cuts async branching overhead by 58% while LangGraph provides deterministic time-travel state recovery. Explore production orchestration patterns in the Daily AI World workflows directory to see how modern engineering teams structure resilient autonomous pipelines. +--------------------------------------------------------------------------+ | AGENT ORCHESTRATION ARCHITECTURAL SHOWDOWN | +--------------------------------------------------------------------------+ | [LlamaIndex Workflows: Event-Driven] [LangGraph: Pregel State Graph]| | Steps emit typed Event objects. Nodes read/write global state. | | Dynamic publish-subscribe pattern. Fixed compiled edges & routes. | | Arbitrary async many-to-many fan-out. Deterministic superstep loops. | | Low memory footprint (sub-2ms dispatch). Heavy checkpointer snapshots. | +--------------------------------------------------------------------------+ Why Orchestration Mechanics Dictate Agent Reliability Under High Concurrency At SaaSNext, our internal code security auditor coordinates 25 specialized verification agents across pull requests. When we built our v1 implementation on LangGraph, our team praised its strict checkpointing model: every node transition is serialized into PostgreSQL, allowing human auditors to inspect agent state and resume interrupted execution with mathematical predictability. However, as our test fleet expanded to hundreds of concurrent pull requests, LangGraph's synchronous graph compilation and state persistence began exacting a steep tax. Every superstep in LangGraph requires serializing the entire application state dictionary, committing database writes, and evaluating conditional edge routers. On complex queries requiring recursive exploration, this snapshotting overhead inflated p99 execution latency past 3,800ms. When we rebuilt the pipeline using LlamaIndex Workflows, the operational dynamics shifted completely. LlamaIndex eliminates the central graph canvas. Instead, each step is an independent asynchronous consumer listening for specific Event subclasses. When an agent step emits a CodeAuditCompletedEvent, the downstream synthesis step activates immediately without writing snapshot blobs to disk. In our benchmarks across high-throughput worker pools, this event-driven architecture reduced step dispatch overhead from 142ms down to 48ms, while keeping CPU consumption low and eliminating thread blocking across parallel branch loops. Side-by-Side Architectural Code Comparison To understand the core developer ergonomics, consider how each framework models dynamic branching and parallel context aggregation. # llamaindex_workflow_sample.py: Event-Driven Routing from llama_index.core.workflow import Workflow, StartEvent, StopEvent, step, Context, Event class SecurityAlertEvent(Event): severity: str finding: str class SecurityAuditWorkflow(Workflow): @step async def triage_code(self, ctx: Context, ev: StartEvent) -> SecurityAlertEvent: code_diff = ev.get("diff") # Direct event emission without updating global graph dictionaries return SecurityAlertEvent(severity="high", finding="SQL injection detected") @step async def dispatch_alert(self, ctx: Context, ev: SecurityAlertEvent) -> StopEvent: return StopEvent(result=f"Dispatched P1 alert: {ev.finding}") # langgraph_state_sample.py: Stateful Pregel Graph from typing import TypedDict, Annotated from langgraph.graph import StateGraph, START, END import operator class AuditState(TypedDict): diff: str findings: Annotated[list[str], operator.add] severity: str def triage_code_node(state: AuditState) -> dict: return {"findings": ["SQL injection detected"], "severity": "high"} def route_decision(state: AuditState) -> str: return "dispatch_alert" if state["severity"] == "high" else "log_info" builder = StateGraph(AuditState) builder.add_node("triage", triage_code_node) builder.add_conditional_edges("triage", route_decision) builder.add_edge(START, "triage") graph = builder.compile() > "In production testing at SaaSNext across 15,000 synthetic multi-branch reasoning tasks, LlamaIndex Workflows reduced mean step dispatch duration from 142ms to 48ms while decreasing memory footprint by 46%." Empirical Benchmark: LlamaIndex Workflows vs LangGraph To quantify execution throughput, memory consumption, and state persistence overhead, we benchmarked both frameworks across 500 concurrent multi-agent executions. | Benchmark Dimension | LangGraph 0.2 (Postgres Checkpointer) | LangGraph (In-Memory Checkpointer) | LlamaIndex Workflows 0.12 | Delta / Engineering Gain | |---|---|---|---|---| | P50 Step Latency | 142 ms | 58 ms | 24 ms | 58.6% faster step execution | | P99 Superstep Overhead | 680 ms | 190 ms | 62 ms | 67.3% lower tail latency | | RAM per 100 Workflows | 4.6 GB | 2.8 GB | 1.4 GB | 50.0% lower memory usage | | State Snapshot Time | 48 ms (DB write) | 6 ms (Dict copy) | 0 ms (Event queue) | Zero disk persistence tax | | Crash Recovery Precision | 100% (Exact step replay) | 0% (State lost on crash) | 88% (Event log replay) | LangGraph wins in durable recovery | | Arbitrary Branching Overhead | High (Requires edge matrix) | Medium | Sub-5ms (Typed event matching) | LlamaIndex wins in dynamic swarms | The benchmark highlights a fundamental architectural trade-off: LangGraph is built for durable, audit-heavy enterprise workflows where time-travel debugging and human-in-the-loop approvals justify checkpointer overhead. LlamaIndex Workflows is engineered for high-throughput, low-latency agent reasoning swarms where dynamic branching speed is paramount. > 💡 Related Engineering Blueprint: Building stateful interrupt loops with durable checkpointers? Inspect our guide on LangGraph Dynamic Interrupts with PostgreSQL: Sub-18ms Resumes to master human-in-the-loop state storage. Common Production Failure Modes: Framework-Specific Hardening When scaling these frameworks across production Kubernetes clusters, engineers encounter distinct failure modes: 1. LangGraph State Bloat: Accumulating large document embeddings directly inside the TypedDict state causes PostgreSQL checkpointer tables to balloon, degrading query times. Always store large payloads in external object stores (like S3) and pass only lightweight URI references in state. 2. LlamaIndex Orphaned Event Starvation: When a step fails to emit an event matching downstream listeners, the workflow hangs until timeout. Enforce global error interceptors configured to emit structured fallback events upon any uncaught exception. 3. LangGraph Checkpoint Deadlocks Under Concurrency: When multiple parallel branches attempt to checkpoint against the same thread ID simultaneously, database lock contention spikes. Use partitioned checkpointers or unique branch thread sub-identifiers. 4. LlamaIndex Memory Leak on Recursive Event Loops: Steps that recursively emit events without decrementing step ceilings cause process memory to expand infinitely. Always set ctx.set("step_count", count + 1) and enforce a strict ceiling. Architectural Verdict: When to Choose LlamaIndex vs LangGraph Choose LangGraph if your application requires strict regulatory compliance, reversible time-travel debugging, and long-running human-in-the-loop approval workflows that span days. Its Pregel state machine model is unmatched for deterministic auditability. Choose LlamaIndex Workflows if you are building autonomous research swarms, fast query decomposition pipelines, or high-throughput agent routers where sub-50ms dispatch latency and low memory consumption are essential. 📚 Authoritative Primary Sources & Research Citations - 🔗 Official Implementation: LlamaIndex Core Workflows Documentation — Technical specification of the event-driven Workflow and Context engine. - 🔗 GitHub Repository: LangGraph Open-Source Repository — Production codebase for Pregel-based multi-agent graphs. - 🔗 Research Paper: arXiv:2308.08155 — Communicative Agents for Software Development — Peer-reviewed evaluation of multi-agent state coordination paradigms. - 🔗 State Machine Standards: Pregel Distributed Graph Processing Framework — Architectural foundation of Pregel superstep execution models. 🚀 Recommended Next Architecture in This Stack Continue optimizing your autonomous multi-agent stack with our companion guides: - ⚡ Next Logical Implementation: Build an Autonomous LlamaIndex Event-Driven Workflow: Sub-60ms Async Agent Routing — Implement the complete event-driven workflow in production. - 🛠️ Directory Hub: Explore hundreds of production-ready architectures in the Daily AI World Workflows Directory and Model Context Protocol Hub. By <a href="x.com" rel="author">Deepak Bagada</a>, Founder & Editor-in-Chief at Daily AI World. --- > 🌐 Original Source Attribution: > This comprehensive engineering breakdown was originally published on Daily AI World by Deepak Bagada. > > Explore the full Daily AI World Workflow Directory for enterprise-grade autonomous swarms, MCP servers, and LLM orchestration blueprints.
why cutcraft: models are good at writing code and bad at driving UIs. editors are good at direct manipulation and bad at explaining themselves to a model. so both work on the same file, with literal ids prefix-tree/cutcraft
azure-pipelines-terraform#385 @AzureDevOps can you merge this PR?
The Cranston–Li–Su–Wang–Xu (2026) conjecture is true Dave Goel arxiv.org [𝚖𝚊𝚝𝚑.𝙲𝙾] 💬Code: github.com/david44hello/papers_supporting_materia… t.co
@mart14688 Here is the outbound team : romangojiberryAI/gojiberryai-sales-os Try gojiberry.ai free for 7 days and get your API key Get your personalised GTM report here: salesteam.gojiberry.ai
Local-first entity linking: your knowledge graph answers first, Wikidata fills the gaps, sameAs bridges the two Disclosure: Andy, WordLift: this is about a feature of resolve(), our entity-resolution API, that I think is most interesting to this community specifically: the candidate universe doesn't have to be Wikidata. A resolve call carries a dataset_uri, and the worlds compose: - wikidata://public — the default; answers are QIDs. - wordlift://dataset/me — the caller's own WordLift knowledge graph, read with the same key; answers carry the graph's own IRIs. - An inline dataset — up to 5,000 entities (id, name, aliases, description, types, same_as) sent with the request. - wordlift://dataset/me,wikidata://public — local-first chaining: per mention, your graph is tried first, Wikidata second, and each answer reports which world it came from in its own dataset_uri field. If a Wikidata match is one your graph declares sameAs, the answer comes back as your entity with the public ids merged in. Every world goes through the same context ranking and abstention gate: a name your data doesn't contain is no_candidates; a name whose context doesn't fit is low_relevance; either way the answer is an explicit unresolved, never the least-wrong candidate. Two design details that may be of interest here. The first call against a graph reads it (seconds for a small graph, minutes for a large one); until it's ready the API answers 503 with a dataset_warming code and Retry-After, and resolves nothing against a partial graph. And the contract (what a Mention, Candidate and Resolution are) is open: pipeline, clients and gold sets are Apache-2.0 at wordlift/content-analysis; the hosted decision engine is proprietary. The supplied-vocabulary side of this, in 17 seconds. What I'd like this community's view on: for those publishing or consuming KGs, is per-mention provenance (which world answered) the right granularity, or do you expect dataset-level negotiation up front? And how are you handling the sameAs bridge when the public item and the local entity disagree on type?
@Echoofsilence26 Here is the outbound team : romangojiberryAI/gojiberryai-sales-os Try gojiberry.ai free for 7 days and get your API key Get your personalised GTM report here: salesteam.gojiberry.ai
Resupply is now in the official Karoo Extension store I posted about this project here a couple of weeks ago: original post. After the original post, I submitted Resupply for the Karoo extension store. The extension has been approved last week and is finally available from within the Extensions library on your Karoo. No more sideloading! 🥳 Based on recent suggestions and some ideas from my side, I further improved UX and added some new features: - imperial units - auto-build the resupply list in the background - temporary live-mode if a route is loaded, useful if you go off-route for a bit - improved in-app update flow - Australia available as a region - … many more If this extension sounds like it could be useful for you, I would appreciate if you'd give it a try and provide honest feedback :) Resupply helps you plan your (long distance) routes and saves time The extension finds water, food and other stops along your route, shows their opening hours, and tells you when you'll arrive. Save favorites while planning, then use in-ride data fields to see what POIs you are approaching. If no route is loaded, the live mode shows what's around you. A few things that might be useful on a long ride: - Favorites. Star the stops you are aiming for and filter the resupply list down to just those. - Fast list builds. Because the database is on the device, building the resupply list for your route takes a second or two. E.g. building a resupply list for a route of 1000 km through the middle of germany takes less than 2 seconds. - Privacy first. The whole POI database rides along inside the app. The search runs on-device, there is no server, and it works with no cell signal. The only network calls are optional, on-demand lookups for opening hours, and those only fire when you ask for them. - Live mode. With no route loaded, it searches around your current location and updates as you ride. - 12 categories. Restaurants, supermarkets, café and bakery, water, toilets, bike shops, fuel stations, ice cream, hotels, pharmacies, ATMs, and campgrounds. Toggle them on and off on the fly. - Safe water by default. Shows drinkable water and hides sources of unknown quality unless you want to see them. - Map pins and data fields. Pins on the map match your current selection. You can also put upcoming resupply, favorites, or any single category straight on your ride data pages, with distance ahead and detour. - Regional coverage. Download the regions you ride, right on the device. Europe, the USA, Canada and Australia are supported so far. - Low energy consumption. Only basic math is performed during ride, calculating remaining distance to POIs and the ETA. This extension has close to no impact on your devices battery life. Actively maintained The extension is under continuous development, so expect regular updates and fixes. Feedback and bug reports are very welcome. The Extension is fully open-source and free of charge. Links - Source code and releases: link to project - Original post: original post
@akarshawasthi99 Here is the outbound team : romangojiberryAI/gojiberryai-sales-os Try gojiberry.ai free for 7 days and get your API key Get your personalised GTM report here: salesteam.gojiberry.ai
most 'ai video editors' give the model 100 tools to drive. cutcraft gives it one artifact: code. drag a clip in the timeline and the file changes by one token. the model reads the new file and sees what you did prefix-tree/cutcraft
I reverse engineered @solana I reverse engineered @pumpfun This week we reverse engineer… Orderbooks and percolation. github.com/themusebook/simd-qubo-ordering/blob/ma…
edge-tts: Edge's online text-to-speech service from Python
Kiro Crew: A persistent workspace for development work that self-improves and continues beyond one session (4.7k stars) What it does All text below is quoted directly from the project README. >A persistent workspace for development work that self-improves and continues beyond one session. Why Kiro Crew: - Persistent. Sessions, memory, schedules, and task checkpoints survive Gateway restarts, and scheduled or reactive work continues without someone at the terminal. - Self-learning. Corrections and task failures become durable lessons. Preferences and project context carry into new sessions. - Self-evolving. Repeated patterns become reusable skills. Memory, lessons, and skills stay visible and editable, so each Kiro Crew grows more tailored to the person and work around it. - Runs where you choose. Your Mac, a local container, or a remote machine you control. - One Gateway, many surfaces. Work directly in the desktop app or web dashboard, or continue the same work from the CLI and messaging surfaces like Slack and Discord. >curl -fsSL download.crew.kiro.dev | sh Repository kirodotdev/KiroCrew Repository stats |Metric|Value| |:-|:-| |Stars|4,653| |Forks|911| |Last release|v0.11.0 (2026-10-30)| |Languages|Python 72.4%, TypeScript 23.2%, JavaScript 3.9%| |Contributors|357| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|@claude (196 commits), @cursoragent (2 commits), @Copilot (1 commits)| |AI co-authored commits|Claude: 239, Codex: 1, Cursor: 5, Copilot: 1| Main contributor |Field|Value| |:-|:-| |Name|Bolin Chen| |GitHub|@bolichen97| |Commits to this repo|2,372 (top contributor)| |Company / Location|Seattle| |Followers|55| ────────────────────────────── 📌 If you want to browse more repos like this, we've organized them by category and rankings here: bestgithubrepositories.com 🗂️ We're also archiving repos where possible, so useful projects don't disappear when they're removed from GitHub.
@trishaghoshh_ Here is the outbound team : romangojiberryAI/gojiberryai-sales-os Try gojiberry.ai free for 7 days and get your API key Get your personalised GTM report here: salesteam.gojiberry.ai
tprtdll.dll exposes equivalents of some ntdll.dll functions at separate addresses, so calling them could avoid hooks placed specifically in ntdll.dll
$YES fees claimed by github.com/recrushawn on @BagsApp 💰 bags.fm
🚀 It's finally COMPLETE! I've officially finished my Sunrise Coffee Chain Performance Analysis (2023–2024). What caught my attention: transactions increased by 16.86%, while revenue and net profit both declined. The data had a story to tell. 🧵👇 github.com/Cephasia 👇👇 t.co
open-sourced cutcraft: a video editor where the file is the video. a model writes one TSX file, the browser renders it, and the timeline edits that same file. no project doc, no tool catalog, no second renderer for export prefix-tree/cutcraft
apple-hig: Apple Human Interface Guidelines for Agents (700 stars) What it does All text below is quoted directly from the project README. >Apple Human Interface Guidelines for Agents Redesign for iPhone Duo: - Assess the current screens, bars and layouts in your code. - Match them against Apple's iPhone Duo guidance and tech talks, with sources. - Decide: it recommends options and stops for your choices, offering SwiftUI previews first. - Build the changes natively, in Apple's order. - Verify them in the Device Hub iPhone Duo simulator where available. - It never makes HTML or web mockups, and it reports which checks it could not run. >Use apple-hig to review the navigation and accessibility of this iOS app. Repository justinwetch/HIGAgentSkills Repository stats |Metric|Value| |:-|:-| |Stars|700| |Forks|27| |Last release|None| |Languages|Python 100%| |Contributors|1| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|None| |AI co-authored commits|None| Main contributor |Field|Value| |:-|:-| |Name|Justin Wetch| |GitHub|@justinwetch| |Commits to this repo|15 (top contributor)| |Bio|Bestselling poet, product designer, artist, photographer, designer (10| |Company / Location|anchorage| |Followers|42| ────────────────────────────── 📌 If you want to browse more repos like this, we've organized them by category and rankings here: bestgithubrepositories.com 🗂️ We're also archiving repos where possible, so useful projects don't disappear when they're removed from GitHub.
【GitHub】max-sixty/worktrunk:面向并行 AI 智能体工作流的 Git worktree 管理命令行工具。 Git worktree 是AI 兴起才被重视的吗?@grok max-sixty/worktrunk
Repo: emanuele-em/kanzo. Built by emanuele-em. Dan Kornas shared it.
@linktulu The ≤100K band rewards small prompts, and a general-purpose subagent's prompt opens with your CLAUDE.md files, skills list and MCP tool names. omitClaudeMd: true and a tools allowlist keep a Haiku helper small. I published a script that prints yours: mdalexandre/claude-code-lean-agents
Model-atlas - An open-source model capability catalog and router for Node.js Meet model-atlas - An open-source model capability catalog and router for Node.js and Electron's headless core. Published as u/spec-kitty/model-atlas under MIT license. Model names do not reliably describe gateway capabilities. A gateway can serve a vision-enabled variant of a text model, reject sampling parameters supported elsewhere, or expose different limits. Hardcoded model tables drift. Model Atlas reads each endpoint's listing, fills gaps from public catalogs, optionally tests capabilities with small real requests, and preserves the evidence behind every decision. TypeScript, strict mode, ESM only, Node 22+, zero runtime dependencies. Uses global fetch, with injection for tests and custom transports. No browser UI or Electron dependency.
Spire 360 - Maybe the best port (yet) Spire360 is a port of Slay the Spire 2, a game that barely released last year and runs almost perfect on the 360, I could tell this from the very start of the first run. Everything is here, the sound are as the original, the music, the effects, the little animations that the enemies and your characters does, the menu... Everything in a very stable FPS (even though FPS in a card game is not that important, this one runs a lot better than the other port made by Dougie aka u/ Complex_Banana3507; Balatro, which is very surprising, balatro looks a lot less demanding but still two good ports). The install is a bit slow, it took me about 25 minutes in a Ryzen 5 5500, and takes about 20gb of your disk space; you can delete this after the game is done, but if you wanna update it you'll need to wait another 20+ minutes, so if you plan to update it with the original game update schedule you can but those 20gb are going to be on your PC; the set up takes time but is quite easy, you only need the newest WSL installed in your PC which the set up downloads for you. Worth to mention that I think I messed up and made my game English by default, I don't know if I messed up or the game's English only, either way thats a very small problem that you only notice if you're not American so most of you are quite safe. Everything said, this is a legitimate way of enjoying this game, it's not only "oh cool, slay the spire on the 360", no, it's a very solid way to enjoy this game even if you have never played it before. For those who already know and likes the game give it a look, you can import your save from your PC, and for those who never tested it you have one more opportunity to check it out. Cheers for Dougie for this amazing port and to Pheeeenom (aka u/ ConfusionRS) for all the tools that made this possible (this entire port is built on XSDK and Vulkan4xenon, that's the foundation that made this possible). Download of the set up (you obviously need your original game from steam or whatever other store StS2 is available to made everything work, game files not include, do not distribute your converted files in any way): dougieprishpreed/spire360
Idol: A single image to 3DGS object model (536 stars) What it does All text below is quoted directly from the project README. >Idol: a single image to 3D Gaussians. Inference SDK and demo. Model: - Output: 3D Gaussians: 32,768 to 1,048,576 (default 262,144), standard 3DGS .ply - DiT: 370M parameters - Image conditioning: DINOv3 ViT-H+ and FLUX.2 VAE - Decoder: 288M parameters - Background removal: BiRefNet - Sampler: Euler, 50 steps, classifier-free guidance 3.0, time shift 3.0 >python -m idol.sample --image photo.jpg --mode real Repository speridlabs/idol-sdk Repository stats |Metric|Value| |:-|:-| |Stars|536| |Forks|43| |Last release|None| |Languages|Python 100%| |Contributors|1| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|none| |AI co-authored commits|none| Main contributor |Field|Value| |:-|:-| |Name|Alejandro| |GitHub|@Alex44lel| |Commits to this repo|1 (top contributor)| |Company / Location|Unigow| |Followers|12| ────────────────────────────── 📌 If you want to browse more repos like this, we've organized them by category and rankings here: bestgithubrepositories.com 🗂️ We're also archiving repos where possible, so useful projects don't disappear when they're removed from GitHub.
My monitors and TV kept needing different layouts, so I made a free Windows tool to save them I have several monitors and a TV connected to my PC, and I switch between different display setups. I built MonitorSnap for that workflow and have been using it for a while. It's been useful enough for me that I wanted to share it. The idea is simple: arrange your displays in Windows, save a preset, and restore it later with a click, the tray menu, or a global hotkey. It saves positions, resolutions, refresh rates, rotation, primary display, and extended/mirrored layouts. The short preview shows the Presets and Displays pages with my current four-display setup and a few example presets. It's free and open source (MIT), for Windows 10/11 x64. There are installer and portable downloads, plus MSI and ZIP packages. No account, Python installation, or Node.js installation is needed. Settings and presets stay local, with a GitHub check for updates. It restores display configurations, not individual application window positions. The drag editor is experimental and the Windows downloads are currently unsigned. Source, screenshots, usage guide, and downloads: GTRows/MonitorSnap I'm open to feedback, feature ideas, bug reports, and fixes. PRs are welcome. If you use a multi-monitor or TV setup, I'd especially like to know which part of switching layouts is still annoying for you.
@ogivus Reality детектируется - ban6cat6/aparecium. Не надо его использовать. Используйте vless-tls за обратным прокси веб-сервера.
Use it → alvarosouza01.github.io Open source, clone it to make your own: alvarosouza01/thumbsmith
Check every reference before arXiv does In May 2026 arXiv announced that it will ban authors for a year when a submission contains references that do not exist (Nature, The Next Web). After the year, they can post only papers already accepted at a peer-reviewed venue. The rule does not ban AI help. It punishes unchecked output, and an invented reference is the easiest unchecked output to prove. CVPR 2027 papers are due on 16 November. If a language model touched your related work or your .bib, this post shows how to check every entry: first one reference by hand with Crossref's free API, to see what can go wrong, then a whole paper in one command. Three ways a reference goes wrong 1. It does not exist. A plausible title, a real venue, page numbers that look right, and no paper behind them. 2. The DOI is wrong. It belongs to another paper (one digit off: 10.1109/CVPR.2016.90 is ResNet, .91 is YOLO), or it is not registered at all. 3. The details are wrong. Real paper, but the year, the venue, the pages or the author list differ from the publisher's record. This post covers the first two: they are what gets a paper flagged. The third needs a field-by-field comparison with the publisher's record, which is a bigger job. Here is a small paper with six references and three of them broken. The ResNet entry carries YOLO's DOI, the LeCun et al. entry carries an unregistered DOI, and lin2022sparse is invented (no registry has it, and neither does a web search for the exact title). {% details refs.bib (six entries) %} @article{harris2020numpy, title = {Array programming with {NumPy}}, author = {Harris, Charles R. and Millman, K. Jarrod and van der Walt, St{\'e}fan J. and Gommers, Ralf and others}, journal = {Nature}, volume = {585}, pages = {357--362}, year = {2020}, doi = {10.1038/s41586-020-2649-2} } @inproceedings{vaswani2017attention, title = {Attention is All you Need}, author = {Vaswani, Ashish and Shazeer, Noam and Parmar, Niki and Uszkoreit, Jakob and Jones, Llion and Gomez, Aidan N. and Kaiser, {\L}ukasz and Polosukhin, Illia}, booktitle = {Advances in Neural Information Processing Systems}, volume = {30}, pages = {5998--6008}, year = {2017} } @misc{openai2023gpt4, title = {{GPT-4} Technical Report}, author = {{OpenAI}}, year = {2023}, eprint = {2303.08774}, archivePrefix = {arXiv}, primaryClass = {cs.CL} } @inproceedings{lin2022sparse, title = {Sparse Mixture-of-Experts Routing with Learned Temperature Schedules}, author = {Lin, Mei and Okafor, Daniel}, booktitle = {Advances in Neural Information Processing Systems}, volume = {35}, pages = {11204--11216}, year = {2022} } @inproceedings{he2016resnet, title = {Deep Residual Learning for Image Recognition}, author = {He, Kaiming and Zhang, Xiangyu and Ren, Shaoqing and Sun, Jian}, booktitle = {Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}, pages = {770--778}, year = {2016}, doi = {10.1109/CVPR.2016.91} } @article{lecun2015deep, title = {Deep learning}, author = {LeCun, Yann and Bengio, Yoshua and Hinton, Geoffrey}, journal = {Nature}, volume = {521}, pages = {436--444}, year = {2015}, doi = {10.1038/nature145390} } {% enddetails %} Checking one reference by hand Two free services answer most questions. doi.org says whether a DOI is registered with any agency (Crossref, DataCite and the rest; asking Crossref alone would miss arXiv's and Zenodo's DOIs). Crossref says whose DOI it is and searches its more than 180 million records for a reference you paste in. Neither needs a key. This script uses only Python's standard library: import difflib, json, sys, urllib.error, urllib.parse, urllib.request MAILTO = "you@example.org" # Crossref asks scripts to say who they are def get(url): req = urllib.request.Request(url, headers={"User-Agent": f"check_ref (mailto:{MAILTO})"}) with urllib.request.urlopen(req, timeout=30) as r: return json.load(r) def similarity(a, b): return difflib.SequenceMatcher(None, a.lower(), b.lower()).ratio() def check(title, doi=None): print(title) if doi: try: # is the DOI registered at all? (any agency: Crossref, DataCite, ...) get(f"https://doi.org/api/handles/{doi}") except urllib.error.HTTPError: print(f" DOI {doi} is not registered") else: # whose DOI is it? other = get(f"https://api.crossref.org/works/{doi}")["message"]["title"][0] print(f" DOI {doi} -> {other!r} ({similarity(title, other):.2f})") query = urllib.parse.urlencode({"query.bibliographic": title, "rows": 3, "mailto": MAILTO}) for item in get(f"https://api.crossref.org/works?{query}")["message"]["items"]: found = item.get("title", ["(no title)"])[0] print(f" {similarity(title, found):.2f} {found}") check("Deep Residual Learning for Image Recognition", "10.1109/CVPR.2016.91") check("Deep learning", "10.1038/nature145390") check("Sparse Mixture-of-Experts Routing with Learned Temperature Schedules") check("BLEU: a Method for Automatic Evaluation of Machine Translation") What it printed: Deep Residual Learning for Image Recognition DOI 10.1109/CVPR.2016.91 -> 'You Only Look Once: Unified, Real-Time Object Detection' (0.32) 0.49 Multiple butterflies recognition based on deep residual learning and image analyze 0.90 Deep Residual Learning for Image Recognition: A Survey 1.00 Deep Residual Learning for Image Recognition Deep learning DOI 10.1038/nature145390 is not registered 0.58 What’s Deep About Deep Learning? 0.44 Designing Deep Learning: Learning Partnerships 0.72 Deep Learning in Action Sparse Mixture-of-Experts Routing with Learned Temperature Schedules 0.44 Efficient Routing in Sparse Mixture-of-Experts 0.39 Omni-Router: Sharing Routing Decisions in Sparse Mixture-of-Experts for Speech Recognition 0.34 Supplemental Information 2: Code Implementation for the Heuristic Sparse Mixture-of-Experts Framework. BLEU: a Method for Automatic Evaluation of Machine Translation 0.12 BLEU 0.56 Tangled up in BLEU: Reevaluating the Evaluation of Automatic Machine Translation Evaluation Metrics 0.35 Table 10: Evaluation results of Hindi-to-Dogri machine translation using BLEU, TER, METEOR, and WER metrics across different models and sentence lengths. The two DOI problems show up at once: one DOI belongs to YOLO, the other is not registered anywhere. The invented paper's best match scores 0.44. So far so good. Now look at the real papers: - LeCun, Bengio and Hinton's "Deep learning" (Nature, 2015, cited more than 80,000 times) is not in the top three. A two-word title is too generic for a title-only search. - BLEU, cited more than 20,000 times, scores 0.12. Crossref stores its title as "BLEU" and the rest as a subtitle. - ResNet is found at 1.00, but right above it sits "Deep Residual Learning for Image Recognition: A Survey" at 0.90. A threshold loose enough to forgive small typos accepts the survey as the paper. Thirty lines catch the obvious cases and then raise false alarms on famous papers. Every false alarm teaches you to ignore the next one, invented references included. The traps a title match falls into These come from running checks like the one above on real bibliographies and on a few hundred labelled references. Each one produced a false alarm or a false "found" before it was handled: - Short and generic titles. Search with the whole reference (authors, year, venue), not the title alone; Crossref's query.bibliographic takes the string as you would write it. Then compare authors, not just titles. - Subtitles stored separately. Compare against title plus subtitle, and accept the part before the colon ("BLEU") only when the authors and year agree. - Near-identical titles. A survey, a "Conditional" version or a follow-up paper sits one edit away from the original. Invented references often look like this too: a real-sounding title one step from a real one. Require the authors to match as well. - Conference papers without DOIs. ICLR, ICML (PMLR) and most NeurIPS papers have no Crossref DOI, so Crossref cannot confirm them. OpenAlex, DBLP and arXiv can. Crossref even holds recent re-registrations of famous NeurIPS papers by unrelated organisations, so a Crossref hit on such a paper may not be the paper at all. - Renamed preprints. arXiv keeps the identifier when authors change the title. An entry with the old title is still real: look the identifier up and compare authors and year. - Borrowed identifiers. Invented references often carry a real arXiv identifier or DOI. A link that resolves proves nothing until the record is the same work. - Versioned DOIs. A Zenodo concept DOI resolves to the latest release, whose title changes with each version. - LaTeX in titles. Strip braces and turn {\'e} and {\L} into letters before comparing. - Rate limits. Send your email to Crossref (its "polite pool"), keep arXiv to one request every three seconds, and when a service shows a bot check (DBLP's search does to scripts), treat it as unavailable rather than working around it. A whole paper in one command We put these rules into a free, MIT-licensed command-line tool, Reference Verifier (disclosure: it is ours). Install it from PyPI and point it at the .tex you will submit: pip install reference-verifier export REFVERIFY_MAILTO=you@example.org refverify paper.tex It follows \input and \bibliography, checks only the keys the paper cites, and asks Crossref, OpenAlex, DBLP, arXiv and PubMed. On the paper above, with an empty cache, it took five seconds: Reference Verifier 0.2.2: 6 references from refs.bib 3 found · 1 not found · 1 wrong DOI · 1 unregistered DOI WRONG DOI he2016resnet Deep Residual Learning for Image Recognition (2016) DOI 10.1109/cvpr.2016.91 belongs to a different work: "You Only Look Once: Unified, Real-Time Object Detection"; the cited work itself exists (found in Crossref) BAD DOI lecun2015deep Deep learning (2015) DOI 10.1038/nature145390 is not registered; the work itself exists (found in Crossref), so the DOI is wrong NOT FOUND lin2022sparse Sparse Mixture-of-Experts Routing with Learned Temperature Schedules (2022) no matching work in Crossref, OpenAlex or arXiv; DBLP could not be reached Not found means no registry lists a matching work. Check those entries by hand before changing anything: books, theses, reports and very new papers are often missing. Requests: api.crossref.org 9, api.openalex.org 1, dblp.org 1, doi.org 1, export.arxiv.org 2 (repeat runs use the local cache) The wrong DOI is reported with the paper it really belongs to, the unregistered one as unregistered, and in both cases the cited paper itself is found, including the "Deep learning" paper the title-only search missed. The invented paper is not found. DBLP's search turned the run away with a bot check that day; the tool says so instead of pretending it looked. The exit status is 1 when a journal or conference reference is not found or has a bad DOI, so it works in scripts. --json results.json writes every result with the record it matched: refverify paper.tex --json results.json jq -r '.results[] | select(.status != "found") | "\(.key)\t\(.status)"' results.json lin2022sparse not_found he2016resnet doi_other_work lecun2015deep doi_not_found On Overleaf: File > Download as source (.zip), unzip it, and run refverify on the main .tex in that folder. In a paper repository: this GitHub Actions job fails the build when a reference is not found or a DOI is wrong. It failed on the paper above and passed once the three entries were fixed: name: references on: [push, pull_request] jobs: check: runs-on: ubuntu-latest steps: - uses: actions/checkout@v7 - uses: actions/setup-python@v7 with: python-version: "3.12" - run: pip install reference-verifier - run: refverify paper.tex env: REFVERIFY_MAILTO: you@example.org How well it works A tool like this is only useful if it rarely cries wolf on real papers and rarely lets an invented one through. We measured it on 246 labelled references built separately from the ones the rules were tuned on, scored once, with no changes afterwards (data and labelling rules). The scores are for version 0.2.0; later versions so far change only how results are shown and how it is installed: | Measure | Result | 95% CI | |---|---|---| | Real references found | 94 of 95 | 94.3–99.8% | | Fabricated references flagged | 54 of 54 | 93.4–100% | | Wrong DOIs flagged as a DOI problem | 30 of 30 | 88.6–100% | | Retracted papers found (they exist; this check does not flag retractions) | 35 of 35 | 90.1–100% | | Flags that were right (fabricated or wrong-DOI entries, out of all flags) | 84 of 85 | 93.6–99.8% | The one real paper it missed is an ICLR 2022 paper without a DOI that only DBLP lists, on a day DBLP's search turned it away. The real references span computer science, biomedicine, physics, mathematics, social science and the humanities. The fabricated ones come from public collections of hallucinated citations found in ACL-family papers and ICLR 2026 submissions, so all 54 are computer science: the fabricated-reference score says less about other fields. What it cannot tell you - Not found is not proof of fabrication. Books, theses, reports and very new papers are often missing from registries. Search the exact title in quotes before deleting anything. - Found is not the same as correct. A real paper with the wrong year, venue or author list passes an existence check. - Whether the paper says what you cite it for. Only reading it tells you that. - Retractions. A retracted paper exists, so it is "found". Retraction Watch's database, which Crossref publishes openly, lists retractions by DOI. It sends titles, first authors, years and identifiers to the registries and nothing else, and keeps their answers in a local cache for 30 days, so reruns are fast and light on the services. Before you submit 1. Run refverify on the exact .tex you will submit. 2. For every NOT FOUND, search the exact title in quotes. If you cannot find the paper, remove the citation. 3. For every WRONG DOI or BAD DOI, copy the DOI from the publisher's page. 4. Rerun until the summary says only "found". Code, issues and the benchmark are on GitHub. An AI agent wrote this post for Aurora Lab. Every command and output above was run for real on 2 November 2026: reference-verifier 0.2.2 from PyPI on Python 3.14, and the GitHub Actions job on Python 3.12.
Another Python project hit by a problem I discussed at PyCon US 2026: AI makes producing reports cheap, while reviewing, validating and fixing them still takes real maintainer time. After 17 years, Andi Albrecht has decided to stop maintaining sqlparse, used by Django and many other projects. Thank you Andi for all these years of work ❤️ sqlparse#945 #Python #OpenSource #Django #AI #SQL #SQLparse
@dr_sensor Just pushed a commit today to fix this. The default kernel with 7.3.2 will include rust now! :) See: linux-cachyos#1123
StableGen: Generate, texture and rig 3D assets in Blender (1.3k stars) What it does All text below is quoted directly from the project README. >Transform your 3D texturing workflow with the power of generative AI, directly within Blender! What it does: - Texture any model: Place cameras around one object or a whole scene. StableGen generates a view from each camera and projects it onto every surface that camera sees; each view is generated with the earlier ones as context, so the texture stays consistent all the way round. - Edit part of a texture: Paint over the part you want to change and describe the change. Masked Edit regenerates only the painted region, in every view that sees it, and leaves the rest of the texture as it was. - PBR materials: Marigold estimates albedo, roughness, metallic and normal maps from the generated views. StableGen projects them like the color and bakes them into standard maps for other software. - Rig and animate: SkinTokens adds a skeleton and skin weights to a character, during a TRELLIS.2 run or on any mesh you select. Motion from FBX or BVH files, such as Mixamo animations, can then be retargeted onto the rig. - Export to a game engine: Bake the result, PBR maps included, into UV textures and export it with its rig and animations: glTF for Godot and the web, or FBX for Unreal Engine and Unity. >Press N in the 3D Viewport and open the StableGen tab. Repository sakalond/StableGen Repository stats |Metric|Value| |:-|:-| |Stars|1,290| |Forks|119| |Last release|v0.4.0 (2026-10-28)| |Languages|Python 100%| |Contributors|7| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|@claude (1 commit)| |AI co-authored commits|Claude: 1| Main contributor |Field|Value| |:-|:-| |GitHub|@sakalond| |Commits to this repo|239 (top contributor)| |Bio|Student at CTU in Prague| |Company / Location|Prague, Czechia| |X / Twitter|@sakalond| |Followers|37| ────────────────────────────── 📌 If you want to browse more repos like this, we've organized them by category and rankings here: bestgithubrepositories.com 🗂️ We're also archiving repos where possible, so useful projects don't disappear when they're removed from GitHub.
tprtdll.dll - A replacement of ntdll.dll for EDR hooking evasion In a nutshell ➡️ tprtdll.dll exposes equivalents of some ntdll.dll functions at separate addresses, so calling them could avoid hooks placed specifically in ntdll.dll ivancabrera02/tprtdll-Injection
💻 Day-342/365 series of Consistent-Coding-Daily-DSA! 💻 ✅ Minimum Moves to Equal Array Elements II (LC) [O(n logn), O(1)] 💾 Code: github.com/Ashutosh2128/Consistent-Coding-Daily-D… #365DaysOfDSA #DSA #LeetCode #GeeksforGeeks #CodingChallenge #ProblemSolving #Consistency #CodeEveryday t.co
Kokino Forensic Toolkit (Kokino FTK): open-source disk forensics in your browser. E01, raw and VHD images; NTFS, FAT, exFAT and ext2/3/4, live and deleted. - zeroscience/Kokino
DeadFrontier Overview Comunity Open Source Hey everyone! I've been building DeadFrontier Overview, a community companion for Dead Frontier. I'd love to get more people testing it or contributing! It has two parts: - Browser extension: quick deposits/withdrawals and buff timers for city pages. - Windows app: an in-game overlay with XP/hour, session history, background loot OCR and estimated item values. Sessions are saved when the game client closes, and reopening starts a new one. Equipment uses Yard/NPC values; other items use public market prices. Shift + F takes an extra loot snapshot while OCR continues in the background. The interface supports English and Portuguese. OCR runs locally, without screenshot uploads. Loot tracking is still experimental: it records items seen in the dialog and their potential value, without verifying inventory entry. Testing, bug reports, suggestions and code contributions are welcome! github.com/raryson/deadfrontier-overview/blob/cod…
The source for Pumpkin Parade Guardian is up — a Halloween tower-defense game for Game Boy Advance, built for the GoedWare Halloween jam: retroromrunner/pumpkin-patch-td #gaming #retro #retrogaming #indiedev
@nitesh_singh5 I'm interested. AI engineer, Python and TypeScript, built RAG and LangGraph agents, can start now. FoodSpector, built solo, 500+ real audits: foodspector.pro Code review agent: the-niresh/plug-and-play-reviewer Portfolio: niresh.in Resume: drive.google.com
🚨Toxssin - An XSS exploitation command-line interface and payload generator. t3l3machus/toxssin t.co
Google AI ProのウィンドウLimitを表示するWindows用のデスクトップガジェットを作った。 Microsoft Storeで配信しようかな。 まず無料で、ある程度品質が安定したら100円くらいで売ってみるかな。 mowthow-works/google-ai-limit-monitor t.co
If India's AI rules ask for a stop button, teams will need a way to prove it works. Three tests to run in CI, not in a slide: • stop → zero new tool calls • timeout → no half-written records • retry → exactly one payment Open-source runner: srpadmanabhuni/agentest
Model-atlas – An open-source model capability catalog and router for Node.js
I use multiple monitors and a TV on my PC, so I built MonitorSnap to save my display layouts I have several monitors and a TV connected to my PC, and I switch between different display setups. I've been using MonitorSnap for a while, and being able to save a layout and bring it back has been really useful for me. I'm the developer, and I'd like to share it with others who have similar setups. You arrange your displays in Windows, save a preset, then restore it from the app, tray menu, or a global hotkey. It captures positions, resolutions, refresh rates, rotation, primary display, and extended/mirrored configurations. The screenshots show my current four-display setup and a few example presets. It's free and open source under the MIT license, for Windows 10/11 x64. Installer, MSI, portable, and ZIP downloads are available. You don't need Python or Node.js installed, and there's no account to create. Presets stay local; the app checks GitHub for updates. A couple of limits: it restores display configurations rather than individual app window positions, the drag layout editor is experimental, and the Windows binaries are currently unsigned. Source, usage guide, and downloads: GTRows/MonitorSnap I'm open to suggestions, bug reports, and contributions. If you try it with a different GPU, dock, KVM, or TV setup, I'd love to hear what works and what needs fixing. PRs are welcome too.
Forecasting the U.S. Senate with Prediction Markets and Monte Carlo Simulations Update 11.04.2026 I backed my forecasts with actual positions on Kalshi! Here are the closed Senate and House bets, where my 11.01.2026 Senate model showed up to a 15% edge for Democrats. <p align="center"> <a href="github.com/bartczernicki/USSenateElectionsForecas…"> <img src="raw.githubusercontent.com" alt="Kalshi Senate position" width="49%"> </a> <a href="github.com/bartczernicki/USSenateElectionsForecas…"> <img src="raw.githubusercontent.com" alt="Kalshi House position" width="49%"> </a> </p> Forecasting the U.S. Senate with Prediction Markets and Monte Carlo Simulations Prediction markets price both individual Senate races and overall Senate control. This article tests whether those prices tell the same story. We combine individual race probabilities with Monte Carlo simulations and compare the resulting chance of Senate control with the overall market contract. As of 11.01.2026, Kalshi's overall contract gives Democrats a 71% chance of controlling the Senate, while our simulations using its individual race probabilities estimate roughly a 76%–86% chance. We'll walk through the inputs, compare independent and correlated simulations, and explore whether that gap suggests a potential market opportunity. Background on the 2026 Senate Races Key Information: - Current balance of power: There are a total of 100 U.S. senators (2 senators for every state in the U.S.). Republicans hold 53 seats, compared with 45 Democrats and two independents who caucus with them, giving the Democratic bloc 47 seats. (Ballotpedia) - Senate Election map: On 11.03.2026, voters will decide 35 of the Senate's 100 open seats: a total of 33 regular elections plus special Senate elections in Florida and Ohio. Republicans defend 22 seats and Democrats defend 13. (Ballotpedia) - What Democrats need: A net gain of four seats brings their bloc to 51 and gives them control. Holding all their current seats means flipping four Republican seats; each Democratic loss requires another pickup. (Inside Elections) - What Republicans need: 50 seats are enough to retain control, because Republican Vice President J.D. Vance can break ties. Republicans can therefore lose three seats net and still control the chamber at 50-50. (U.S. Senate) In this article, we will demonstrate a forecast of the 35 US Senate race outcomes & combine the forecasts with the 65 existing US Senate seats not on the ballot. This will determine the final 100 US Senate totals and each party's probability of controlling the Senate. Background on Prediction Markets Prediction markets such as Polymarket and Kalshi let people buy and sell contracts on questions like, "Will this candidate win?" Trading turns those competing views into a probability that changes as new information arrives. A market resolves when it confirms the outcome under its rules and settles the contracts. !How Kalshi Contract Market Works Workflow of Kalshi Market Contracts. Image credit: Trade the Outcome. Key Concepts: - Prices represent probabilities: A "YES" contract priced at $0.65 implies about a 65% chance of the event happening. In a standard binary market, that contract pays $1 if the event happens and $0 if it does not. The percentage describes the chance of winning, rather than the candidate's expected share of the vote. (Polymarket overview) - You can sell before the result: Like stocks, contract prices rise and fall. Buying at $0.65 and selling at $0.80 earns $0.15 per contract before fees; selling at $0.45 instead loses $0.20 ($0.65 - $0.45 = $0.20). Traders can take a profit or limit a loss before resolution, provided another trader will buy. (Polymarket trading guide) - Collective Intelligence: Traders bring different polls, news, expertise and local knowledge. Their buying and selling combines that information into one price: the wisdom of markets. Someone who thinks the price is wrong has an incentive to trade against it, helping the market update. (Polymarket overview) !James Surowiecki on the wisdom of crowds - People put money behind their beliefs: Financial stakes give a forecast more accountability than a casual opinion. This connects with the core them in Annie Duke's book Thinking in Bets. That makes prediction market prices useful evidence, as traders are materialy invested in their forecast beliefs. (Annie Duke on thinking in bets) <p align="center"> <a href="penguinrandomhouseretail.com"><img src="images.penguinrandomhouse.com" alt="Thinking in Bets by Annie Duke — book cover" width="150"></a> </p> - Calibration means the percentages match reality: Across many comparable events assigned a 70% chance, roughly 70 out of 100 should happen (within statistical boundary) in a well-calibrated market. If the forecast is way over in its forecast versus the reality, it is considered overconfident. Conversely, a forecast that is way under its forecast is considered underconfident. (Research on market calibration, 2026) !Decision assurance and probability calibration - Forecasts often improve closer to resolution: Kalshi's own August 2026 study of more than 2.2 million resolved markets found prices generally well calibrated near resolution, with forecast errors declining as markets approached their close. This supports using near-election prices as inputs, while calibration still needs to be checked against actual outcomes. (Kalshi Research, 2026) U.S. Senate Races on Prediction Markets Prediction markets offer both macro contracts for the overall election and detailed contracts for each individual Senate race: - Overall Senate control: This contract asks which party will control the U.S. Senate. The 11.01.2026 screenshot below shows a 71% chance for Democrats and 29% for Republicans. <p align="center"> <a href="raw.githubusercontent.com"><img src="raw.githubusercontent.com" alt="Kalshi Senate-control market showing Democrats at 71% and Republicans at 29%" width="500"></a> </p> - Individual Senate races: Separate contracts cover each state's race. For example, the 11.01.2026 Texas screenshot shows James Talarico at 69% and Ken Paxton at 31%. <p align="center"> <a href="raw.githubusercontent.com"><img src="raw.githubusercontent.com" alt="Kalshi Texas Senate market showing James Talarico at 69% and Ken Paxton at 31%" width="500"></a> </p> For our Senate forecast, individual race prices provide the starting estimates. We test whether combining those probabilities produces a Senate-control estimate consistent with the overall contract. A difference could point to potential value, depending on the model assumptions; proximity to Election Day alone does not establish that the prices are well calibrated. Monte Carlo Simulations & Forecast Methodology A Monte Carlo simulation runs a model thousands (or more) of times, using random draws to represent uncertainty. Each run produces one possible future. For our Senate forecast, one run represents an entire election: who wins each race, how many seats each party holds, and who controls the chamber. !Simulation as a way to explore outcomes before acting, illustrated by a person checking a ladder A Monte Carlo simulation lets us explore what could happen before the real event, much like checking a ladder's stability before climbing. Monte Carlo Basics: - Probabilities guide the random draws: In a simple independent simulation, a candidate with a 70% chance wins when a random number between 0 and 1 falls below 0.70. Across many runs, that candidate wins roughly seven times out of ten, while still losing in some simulated elections. - Many runs produce a range of outcomes: Some simulated elections produce a narrow majority; others produce a larger victory for either party. The result is a distribution of possible seat totals, showing both common and less likely outcomes. - Count how often an outcome happens: As an illustration, if Democrats control the Senate in 65,000 of 100,000 simulations, the model estimates a 65% chance of Democratic control. More runs reduce random variation in this estimate; the quality of the forecast still depends on its inputs and assumptions. !Monte Carlo sales forecast showing a distribution of outcomes from 10,000 simulations This sales example illustrates the same principle: repeated simulations produce a range of possible results. U.S. Senate Forecast Methodology: 1. Start with market probabilities: Use Kalshi's 11.01.2026 estimates for the 35 races as inputs. Hold the 65 Senate seats not on the ballot fixed. 2. Simulate a complete election: Generate winners for all 35 races. An independent baseline treats each race separately; a correlated version also includes shared influences that can move several races together. 3. Count seats and determine control: Add the simulated winners to the existing seats, counting independents according to their caucus alignment. Democrats need a bloc of 51; Republicans can retain control with 50 because they hold the vice presidency. 4. Repeat and compare: Summarize the seat distribution and control probabilities across many simulated elections. Compare the independent and correlated results with the overall Kalshi contract to see how the assumptions affect the estimated opportunity. Correlated Outcomes: FLIPR and Shared National Influences Senate races share influences such as national turnout and shifts in voter sentiment. If a forecast misses one of those influences, several races can surprise us together. Nate Silver's FLIPR model combines polls, other indicators such as incumbency and fundraising, and, in its default version, expert ratings. It runs many simulations per update, accounting for uncertainty shared nationally, across similar regions or demographic groups, within a state, and within individual races. (Silver's FLIPR methodology) Think of the national environment as a tide that can help or hurt candidates from the same party across several states. In our correlated model, we assume this shared tide accounts for 12% of the variation in each race's simulated score, while the other 88% comes from uncertainty specific to that race. This is our modeling assumption, not a parameter taken from FLIPR. It allows races in Michigan, Iowa and North Carolina to move together while still producing different results. The shared influence can favor either party; we do not assume a Democratic wave. Simulation Approach and Results The USSenateElectionsForecast console application puts these ideas into practice. Results setup: Both runs use the same 11.01.2026 Kalshi probabilities for the 35 Senate races, plus the 65 seats not on the ballot. We compare an independent model with a correlated model that allows races to move together. The correlated model allows a national surprise benefiting either party; it does not assume a Democratic wave. What the simulation checks: We combine the individual Senate race probabilities through repeated simulated elections, add the seats not on the ballot, and estimate each party's chance of Senate control. We then compare that estimate with the overall Senate contract. Do the individual race prices tell the same story as the overall market? Looking for potential value: A meaningful gap could suggest that a contract is priced too high or too low. The comparison should use probabilities from the same time and matching contract rules. A gap can also reflect assumptions about how races move together, so it signals possible mispricing to investigate. Establishing that a market is poorly calibrated requires checking many forecasts against their actual outcomes. Independent Monte Carlo Simulation: This treats each individual race as 100% independent. For example, the Texas Senate race doesn't impact the Iowa Senate race and vice-versa. Using the Kalshi individual-race probabilities, the independent simulation produces the following seat distribution and probabilities: <p align="center"> <a href="raw.githubusercontent.com"><img src="raw.githubusercontent.com" alt="Independent simulation seat distributions for the Democratic and Republican caucuses" width="500"></a> </p> <p align="center"> <a href="raw.githubusercontent.com"><img src="raw.githubusercontent.com" alt="Independent simulation probabilities of reaching Democratic seat thresholds, including an 86.02% chance of at least 51 seats" width="500"></a> </p> - Democratic control: Democrats reach the required 51 seats or more in 86.02% of simulations. - Most common result: 52 Democratic-caucus seats, occurring in 24.55% of simulations. - A larger majority: The chance of reaching at least 55 Democratic-caucus seats is 7.06%. This model suggests Democrats are favored to capture the Senate, with the most likely results concentrated around a small majority. Correlated Monte Carlo Simulation: This uses the same Kalshi individual-race probabilities while allowing a shared national influence to move races together. A national surprise can help or hurt the same party across several states. <p align="center"> <a href="raw.githubusercontent.com"><img src="raw.githubusercontent.com" alt="Correlated simulation showing a wider distribution of Democratic-caucus seat totals" width="500"></a> </p> <p align="center"> <a href="raw.githubusercontent.com"><img src="raw.githubusercontent.com" alt="Correlated simulation probabilities of reaching Democratic seat thresholds, including a 76.30% chance of at least 51 seats" width="500"></a> </p> - Democratic control: Democrats reach 51 seats or more in 76.30% of simulations. - Most common results: 53 Democratic-caucus seats (16.04%) and 52 seats (15.97%) are nearly tied. - A wider range of outcomes: The chance of reaching at least 55 Democratic-caucus seats rises to 17.33%, compared with 7.06% in the independent model. The shared national influence increases the chances of both strong and disappointing Democratic results. This explains why a larger majority becomes more likely even as the probability of Democratic control falls. Correlation changes which races are won together while preserving each race's starting win probability. Conclusion & Opportunity As of 11.01.2026, the overall Kalshi Senate-control market shows a 71% chance of Democratic control. Simulating the individual Kalshi race probabilities produces higher estimates under both approaches: | Estimate | Democratic control | Difference from market | |---|---:|---:| | Overall Kalshi contract | 71% | — | | Independent simulation | 86.02% | +15.02 percentage points | | Correlated simulation | 76.30% | +5.30 percentage points | The simulations estimate roughly a 76%–86% chance that Democrats capture the Senate, compared with the 11.01.2026 overall market's 71%. That gap suggests a potential opportunity in the market: if the model inputs and assumptions hold, the overall contract may understate the chance of Democratic control. The 76%–86% range represents two model estimates, not a confidence interval. The gap is a reason to investigate possible mispricing; it does not by itself prove that the market is poorly calibrated or guarantee a profit. The simulations flag a potential pricing opportunity under our chosen assumptions. Opportunity This article showed how overall prediction markets that are composed of smaller markets can be potentiallly mispriced. If all of the components are available/priced, we can use simulation techniques, like the Monte Carlo to understand where there is potential value. Breaking the problem down into smaller parts has always been a trick that management consultants used in the past to quantify value and make accurate forecasts. Now you have a path on howto do this yourself! Resources - Decision Intelligence with AI Book: decisionintelligencebook.ai - US Senate Elections Forecast Console App: bartczernicki/USSenateElectionsForecast - System One Decisions Console App: bartczernicki/SystemOneDecisionsConsole
OpenIDEA: The IDE you know, rebuilt in Rust (4.2k stars) What it does All text below is quoted directly from the project README. >The IDE you know, rebuilt in Rust. IntelliJ IDEA-style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages Benchmark: Opening freqtrade (Python, ~770 files) with warm caches, median of 5 runs: |OpenIDEA|IntelliJ IDEA 2026.2.3| |:-|:-| |Window with the project|0.9 s|3.1 s| |Ready (CPU settled)|1.1 s|13.2 s| |Memory (USS, all processes)|169 MB|2011 MB| |CPU time until ready|2.4 s|47.9 s| |Idle CPU|4 % of a core|7 % of a core| |Quit|0.3 s|5.9 s| >Editor, code insight, debugger, Git, terminal, database and HTTP clients, for 60+ languages. Builds for macOS, Windows and Linux. Repository l0ng-ai/openidea Repository stats |Metric|Value| |:-|:-| |Stars|4,247| |Forks|346| |Last release|v0.1.33 (2026-11-01)| |Languages|TypeScript 59.9%, Rust 36.4%, CSS 2.6%| |Contributors|34| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|@claude (6 commits), @cursoragent (1 commit)| |AI co-authored commits|Claude: 6, Cursor: 1| Main contributor |Field|Value| |:-|:-| |GitHub|@l0ng-ai| |Commits to this repo|388 (top contributor)| |Followers|108| ────────────────────────────── 📌 If you want to browse more repos like this, we've organized them by category and rankings here: bestgithubrepositories.com 🗂️ We're also archiving repos where possible, so useful projects don't disappear when they're removed from GitHub.