标签：#t

GitHub热门项目 | Taste-Skill - gives your AI good taste. stops the AI from generating boring, generic slop | Stars: 24,364 | 2,715 stars today | 语言: Shell

GitHub热门项目 | Fully automatic censorship removal for language models | Stars: 22,036 | 211 stars today | 语言: Python

GitHub热门项目 | Kronos: A Foundation Model for the Language of Financial Markets | Stars: 26,898 | 401 stars today | 语言: Python

GitHub热门项目 | 754 structured cybersecurity skills for AI agents · Mapped to 5 frameworks: MITRE ATT&CK, NIST CSF 2.0, MITRE ATLAS, D3FEND & NIST AI RMF · agentskills.io standard · Works with Claude Code, GitHub Copilot, Codex CLI, Cursor, Gemini CLI & 20+ platforms · 26 security domains · Apache 2.0 | Stars: 10,997 | 886 stars today | 语言: Python

GitHub热门项目 | The open alternative to Salesforce, designed for AI. | Stars: 47,351 | 519 stars today | 语言: TypeScript

Last.fm is now an independent company, nearly two decades after it was acquired by CBS.

I used to live in VS Code with GitLens pinned — the branch graph, heat-mapped blame, the lens annotations. That was my git workflow. Then 2026 happened. With Cursor, Claude Code, and Codex doing the actual editing, the editor itself became optional. The only thing dragging me back was GitLens. That felt wasteful — booting an entire IDE just to peek at commit history. The agent runs the git commands now; I only need to sanity-check the result, occasionally, when something looks off. So I built gitwink — the smallest possible tool for that loop. A tray icon that expands into a glance, hands the commit off as AI context, and gets out of the way. Read-only by design. It cannot commit, push, merge, or modify anything. If I need git surgery, I tell the agent. The 0.5-second confirm loop agent commits → tray click → inline expand → "Copy as AI context" → paste into Claude/Codex/Cursor → "did the agent do this right?" No window switching. No IDE boot. The whole loop fits inside a glance. What's in it Tray-resident (Windows tray / macOS menu bar) — click to toggle, global hotkey Ctrl+Shift+G to summon from anywhere. Right-click the tray icon for Reset position / Open settings file / Quit. First-run discovery that walks your usual code dirs ( source , Documents , Projects , Code , Dev , repos , Desktop , every non-system drive on Windows; ~/Projects , ~/Code , ~/Developer on macOS) and caches the result in SQLite. No "add repo" friction. Unified commit timeline across all repos, with chips above for filtering by Repo (search + pinning), Time range (24h / 3d / 7d / 30d / All), and Authors (multi-select with counts). Per-row markers — ● commit · ◆ merge · ★ tagged — and branch label badges when a commit isn't on the currently checked-out branch. Single-repo DAG view — pick a repo and the panel switches to a per-branch graph with a custom SVG lane drawer (eight-colour palette, hashed from branch name; main / master / develop kept neutral). Inline expand on click — commit body +

⚠️ For defensive/educational purposes only. Sniff only networks you own or are explicitly authorized to test. Unauthorized network monitoring is illegal in most jurisdictions. The uncomfortable truth about your factory floor If your plant uses Modbus TCP — and statistically, it probably does — every register read, every coil write, every sensor value is flying across your network in plaintext . No encryption. No authentication. No signature. Nothing. Modbus was designed in 1979 by Modicon for serial communication between a PLC and a few field devices on a dedicated cable. The threat model was "someone might physically tap the wire." The solution was "don't let strangers into the control room." Forty-five years later, that same protocol is running over your corporate VLAN, talking to cloud historians, and occasionally — if your IT/OT segmentation has gaps — reachable from the internet. Let me show you what that looks like from the wire. The 5-line sniffer This is a defensive monitoring tool. Same code your blue team would use to baseline normal traffic and detect anomalies. Requires scapy : pip install scapy from scapy.all import sniff , TCP , Raw def show_modbus ( pkt ): if TCP in pkt and pkt [ TCP ]. dport == 502 and Raw in pkt : payload = pkt [ Raw ]. load print ( f " { pkt [ ' IP ' ]. src } → { pkt [ ' IP ' ]. dst } : { payload . hex () } " ) sniff ( filter = " tcp port 502 " , prn = show_modbus , store = False ) Run it on a span port, a TAP, or a mirror VLAN, and within seconds you'll see something like this: 192.168.1.50 → 192.168.1.10: 0001000000060103006400 02 192.168.1.10 → 192.168.1.50: 00010000000701030441f00000 192.168.1.50 → 192.168.1.10: 00020000000601100065000102 Every byte tells a story. Let's decode the first packet. Decoding what you just captured The Modbus TCP frame format is documented in the spec (it's public — that's part of the problem): Bytes 0-1: Transaction ID Bytes 2-3: Protocol ID (always 0x0000 for Modbus) Bytes 4-5: Length Byte 6: Unit

The Problem We Were Actually Solving Treasure hunts in Hytale arent just about generating loot. Theyre about generating simultaneous loot across thousands of players while keeping the world state consistent. We started with the assumption that events are stateless notifications: a hunt starts, we fire an event, clients react. That model worked fine when we had 200 concurrent players. At 2,000 players, the event bus turned into a 40 MB/s firehose of JSON blobs. Each loot drop required serializing the entire chunk state—blocks, entities, metadata—so clients could render the drop in real time. The JVMs G1GC couldnt handle the allocation rate. Every 47 minutes, a GC cycle would pause for 4.2 seconds, the chunk cache would fragment, and the server would hard crash with an OutOfMemoryError in net.minecraft.server.MinecraftServer#processQueue. The real problem wasnt the hunt logic. It was the architectural laziness of treating events as a catch-all glue layer instead of a boundary layer with explicit interfaces. What We Tried First (And Why It Failed) We tried Kafka as the event bus. The plan was to shard hunts by region and stream loot drops as compacted topics. The first run worked for about 6 hours before the compacted topics started to bloat. Each hunt was generating 700 KB of serialized chunk state per drop. At 30 drops per hunt per minute, thats 21 MB per hunt per minute. With 400 active hunts, the brokers couldnt keep up. The lag grew to 12 seconds, clients started rubber-banding, and we got a flood of Discord reports: You sank my boat! The event stream was now the bottleneck, not the event source. Next, we tried Redis Streams with a Lua script to aggregate loot drops per chunk. Within 30 minutes, we hit the 4 GB maxmemory limit because Lua scripts were stacking dropped items in memory while waiting for the next batch. The script was elegant—O(1) per drop—but the memory footprint made it unusable in production. Finally, we tried a sidecar service: a small Go process

This is a submission for the GitHub Finish-Up-A-Thon Challenge What I Built XGroundControl Station is a professional Ground Control Station (GCS) application built specifically for macOS, designed to provide full control over UAV systems. The project started as an attempt to create a more optimized, native experience for drone control on Mac devices, focusing on performance, usability, and precision. The application allows users to connect to flight controllers, monitor real-time telemetry, perform calibration, test motors, and configure flight parameters in a seamless and efficient workflow. For me, this project represents a step toward building a complete UAV ecosystem, including both hardware and software solutions. Demo You can explore the project and its features through the following: GitHub Repository: https://www.github.com/agaafar7/xgroundcontrolstation.git The Comeback Story Before this challenge, the project was partially implemented with core communication and UI components in place, but it lacked refinement, stability, and several critical features. During the Finish-Up-A-Thon, I focused on completing missing functionalities, improving the communication layer with flight controllers, optimizing performance on macOS, and polishing the UI for a smoother user experience. I also worked on fixing bugs, enhancing telemetry handling, and ensuring reliable real-time interaction with the system. My Experience with GitHub Copilot GitHub Copilot played a significant role in accelerating development, especially when working with complex logic such as telemetry parsing, communication handling, and structuring reusable components. It helped reduce development time by suggesting boilerplate code, assisting with debugging, and providing quick iterations when experimenting with different implementations. Overall, it allowed me to stay focused on architecture and system design rather than repetitive coding tasks.

I understand why so many people are questioning software engineering right now. Every week there’s another headline saying AI will replace developers. Junior engineers are worried there won’t be jobs. Senior engineers are wondering how long their experience will stay valuable. And honestly, if you spend enough time on tech Twitter or LinkedIn, it can start feeling like the industry is collapsing in real time. But after using AI heavily in my day-to-day work as a software engineer, I’ve started seeing things differently. AI didn’t make me feel less useful. It made me feel more capable. Before AI became part of my workflow, a lot of engineering time disappeared into things that were mentally draining but necessary: repetitive refactoring debugging small issues writing boilerplate digging through documentation trying to remember syntax cleaning up legacy code writing SQL queries optimizing simple functions translating vague tickets into technical tasks None of these tasks were impossible. They were just time-consuming. Now, a lot of that friction is reduced dramatically. One of the biggest changes I noticed was backlog cleanup. Tasks that used to sit untouched because nobody wanted to deal with them suddenly became manageable. Not because AI magically solved everything. But because it helped reduce the “mental startup cost” of difficult tasks. Sometimes all you need is: a starting point a refactored example help understanding unfamiliar code a faster debugging path quick documentation summaries That momentum matters more than people realize. A task that feels overwhelming at 9AM suddenly becomes achievable when AI helps break it down. I also noticed we started delivering faster as a team. Not in a “replace developers with AI” kind of way. More in a: less context switching faster research quicker prototyping fewer hours stuck on repetitive problems better ticket breakdowns improved communication kind of way. The interesting part is that AI didn’t just help with coding.

This is a submission for the GitHub Finish-Up-A-Thon Challenge What I Built I built the Closiq Discord Agent , a full-stack modular monolith engineered to transform a Discord channel into an automated, AI-driven customer support inbox and lead management system. When a customer messages your Discord support channel, the backend captures the conversation, handles data persistence, and fetches highly relevant context from a self-hosted Qdrant vector database (which indexes knowledge base documents stored in MinIO). It then leverages OpenRouter or OpenAI-compatible models to dynamically draft and deliver accurate, context-aware responses right back to the customer via a Discord bot. Demo GitHub Repository: ErOr-0/closiq-discord-bot Local Web Dashboard: http://localhost:5173 (Tip: Insert a GIF or a couple of screenshots here showing off your React dashboard interface, your MongoDB message log view, or the Discord bot replying live in a channel!) Tech Stack At A Glance Frontend: React + Vite Backend: Node.js + Express + TypeScript Databases & Storage: MongoDB (Metadata), Qdrant (Vector Embeddings), and MinIO (Object Storage) Integrations: discord.js & OpenRouter / OpenAI SDK The Comeback Story This project started as an ambitious idea but quickly stalled out. Before dusting it off for this challenge, it was just a loose collection of database models, basic tools, and a primitive, unoptimized LangChain loop sitting in a graveyard of unfinished local folders. It completely lacked a front-end management layer, and the architecture was fragile. To bring this project to life and cross the finish line, I focused heavily on stability, user experience, and structural boundaries: Modular Monolith Refactoring: Reorganized the entire Express backend into strict, clean module boundaries ( messages , knowledgebase , agent , infrastructure ) to make the codebase highly maintainable. Built the Web Dashboard: Created a comprehensive React interface from scratch so users can visually mon

Why Does Using an ORM Decrease Database Performance? While trying to optimize the shipping module in a production ERP, I noticed that database queries were incredibly slow. At first, I examined the SQL queries and checked the indexes. However, I couldn't get the performance boost I expected. The problem lay in the Object-Relational Mapper (ORM) library, which was the cornerstone of our application. ORMs make things easier for software developers by providing an abstract layer for database operations, but this convenience often comes at a performance cost. In this post, I will explain why using an ORM decreases database performance, using concrete examples from my own field experience. The core promise of ORMs is to keep developers away from SQL and allow them to interact with databases in a way that is more aligned with the object-oriented paradigm. This is a huge advantage, especially in small and medium-sized projects or rapid prototyping processes. However, when things get complex and performance becomes critical, the efficiency of the queries generated by ORMs starts to be questioned. In many cases I have encountered, especially in enterprise software development processes, the default behaviors of ORMs created an unexpected load on database servers. Query Inefficiencies Generated by ORMs ORMs usually manage database relationships using mechanisms like "eager loading" or "lazy loading". Depending on the developer's preference, these mechanisms either fetch all related data at once (eager loading) or fetch it in pieces as needed (lazy loading). However, ORMs may not always perform these loads in the most optimized way. For example, while only a few fields like ID and name are sufficient in a list view, the ORM might query the entire table or all related tables. This situation causes unnecessary data transfer and unnecessarily overloads the database server. To give an example, on the order list screen of an e-commerce site, we needed to display the customer inform

Disclosure: I work on Passlens, a browser-first passport and ID photo maker. This post is about the product decisions behind that workflow, not a neutral review of every tool in the space. A passport photo looks simple until you try to make one that an upload form will actually accept. It is a headshot, yes, but it is also a small chain of constraints: physical size, pixel size, background, head position, print scale, and whatever the destination country's portal decides to reject that week. That is why generic photo editors feel slightly wrong for this job. They can crop. They can resize. They can export. The hard part is not any one of those actions. The hard part is keeping all of them tied to the document rule the user picked. The unit problem For developers, document photos are awkward because two units matter at the same time. A user may need a 2x2 inch passport photo. A visa portal may ask for 600x600 pixels. A print sheet may need 35x45 mm photos at 300 DPI. These are not the same request, but people often treat them as if they are. If the app only thinks in pixels, the print can come out the wrong physical size. If it only thinks in millimetres or inches, the digital upload can be rejected for the wrong pixel dimensions. A good workflow has to keep both ideas alive: the document size and the export target. That is the main reason Passlens keeps presets and print layouts as first-class pieces of the workflow instead of treating them as labels on a crop box. The crop is not the output Another small trap: the crop the user sees is not always the final output. For a digital upload, the crop usually becomes one image file. For printing, the same crop may become several photos arranged on 4x6, A4, or Letter paper with spacing, margins, and optional cut marks. If that print sheet is scaled by the browser or printer dialog, the whole thing is wrong. So the editor needs to separate three things: the face and shoulder crop the finished document-photo size the print s

What if a development board could be as friendly as an Arduino, yet powerful enough to drive industrial-grade robots? That is exactly the gap the new G2 Nano sets out to close. Most hobby boards handle simple robot builds with ease, but they hit a wall once a project demands tight, simultaneous control of several motors. Embedded systems engineer Ryan Strace noticed that the custom controllers built for these complex machines tend to look remarkably alike, with motor coordination as the recurring headache. Rather than reinventing that hardware on every project, he designed a single accessible platform to handle it, and the G2 Nano is the result. Precise motor control usually leans on closed-loop techniques like PID, but real-world gremlins such as integrator windup, sensor noise, mechanical saturation, and phase delay can all degrade performance. Robots also need smooth multi-axis motion with managed acceleration to avoid jerky, stressful movement, plus solid fault handling so an unexpected state does not wreck expensive parts. Strace is tackling all of this with a low-cost motion-control IC he is developing, and the G2 Nano is the high-performance platform built to prove out that future chip. What's under the hood Processor: NXP Arm Cortex-M7 clocked at a brisk 1 GHz Wireless: u-blox MAYA-W1 module with dual-band Wi-Fi and Bluetooth Motion sensing: six-axis IMU (3-axis accelerometer plus 3-axis gyroscope) and a dedicated magnetometer for compass heading Form factor: just 0.8 by 3 inches, breadboard-friendly, on a six-layer PCB stackup for clean high-speed signals On the software side, the board targets native micro-ROS and the Zephyr real-time operating system, with planned MicroPython support so you can prototype in Python without paying the usual speed penalty, thanks to that unusually high clock. Every design file and document is open-source and published on GitHub. Build it yourself If you want to follow along, the core ingredients are clear: an NXP Cortex-M7 a

A lot of AI apps die in the same place. Not during the prototype phase. Not while testing...

Something broke in the AI pricing market between January and May 2026. A year ago, "frontier model" meant "expensive model." Claude Opus was $15/$75 per million tokens. GPT-4 was $5/$15. If you wanted the best coding performance, you paid the best price. The correlation between quality and cost was loose, but it existed. That correlation is gone. The Numbers That Changed Everything Here's SWE-bench Verified — the benchmark that tests AI models against real GitHub issues from projects like Django, Flask, and scikit-learn — plotted against output price per million tokens: Model SWE-bench Output $/1M Score/Dollar ───────────────────────────────────────────────────────────────── Claude Opus 4.7 87.6% $25.00 3.5 Claude Opus 4.6 80.8% $25.00 3.2 Gemini 3.1 Pro 80.6% $15.00 5.4 GPT-5.2 80.0% $10.00 8.0 DeepSeek V4 Pro (Max) 80.6% $3.48 23.2 Kimi K2.6 80.2% $4.00 20.1 Qwen3.6 Plus 78.8% $3.00 26.3 MiniMax M2.5 80.2% $1.20 66.8 DeepSeek V4 Flash (Max) 79.0% $0.28 282.1 Read that last line again. DeepSeek V4 Flash scores 79% on SWE-bench at $0.28 per million output tokens. Claude Opus 4.7 scores 87.6% at $25.00. The performance gap is 8.6 percentage points. The price gap is 89x . For a team running 100 million tokens per month, that's the difference between $28/month and $2,500/month. For a 9-point improvement in code completion accuracy. It's Not Just One Outlier This isn't a DeepSeek anomaly. Look at the cluster of models scoring 78-80% on SWE-bench: DeepSeek V4 Pro : $3.48/1M output — open source, 1M context Kimi K2.6 : $4.00/1M output — open source, 256K context MiniMax M2.5 : $1.20/1M output — open source, 200K context Qwen3.6 Plus : $3.00/1M output — open source, 1M context MiMo-V2-Pro : $3.00/1M output — open source, 1M context Five models from five different Chinese labs, all scoring within 2 points of GPT-5.2 ($10.00/1M) and Gemini 3.1 Pro ($15.00/1M), all at 1/3 to 1/10 the price. And they're all open source. What Happened Three things converged: 1. Mixture-of-Exper

According to the complaint, a Google engineer risked over $2.7 million on wagers related to Google's 2025 Year in Search campaign.

Author: Tobie Morgan Hitchcock Three months after 3.0 went GA, we're excited to announce that...

Lately I’ve noticed that a lot of people seem emotionally drained from constant social media interaction, notifications, and online pressure. But interestingly, many people seem completely comfortable talking to AI for hours especially when the interaction feels calm and non-judgmental. It’s interesting how many users say they don’t even want “romantic AI.” Do you think AI companionship could eventually become part of digital wellness rather than just entertainment? submitted by /u/Nearby-Ad-8924 [link] [留言]