标签：#pens

⚡ What makes MoilStack .md different? 1. Bring Your Own AI (100% Local or Cloud) Connect any provider without vendor lock-in or middleman servers: Local & Offline: Direct integration with Ollama so your data never touches the internet. Cloud API Support: Works with OpenAI, Anthropic Claude, Google Gemini, Groq, Mistral AI, OpenRouter, Together AI, and Cerebras. Your API keys stay stored locally, and requests go straight from your machine to the provider. Zero telemetry, zero cloud accounts. 2. Native Inline AI Editing Forget copying and pasting between a chatbot window and your file. Highlight any section and ask the AI to rewrite, shorten, expand, or explain it. Edits stream directly into your document. 3. Safety Net: Reversible Edits & Auto Backups AI modifications shouldn't destroy your hard work: Instant Revert: Press Ctrl + Z to instantly undo any AI rewrite and restore your exact document state. Automatic Snapshots: MoilStack .md automatically creates a local snapshot before every AI action, keeping the last 10 versions per file in a local backup directory. 4. Focused Desktop Experience Minimalist UI: Clean writing view with toggle preview and right-click formatting — no clunky toolbars taking up screen space. Local Workspaces: Open any local folder as a workspace to create, rename, and edit .md files directly. One-Click PDF Export: Export your drafts into clean, beautifully formatted PDFs with standard margins and readable typography. Multi-Instance: Double-click any file in your file explorer or open multiple side-by-side windows independently. 🛠️ Tech Stack & Availability MoilStack .md is open source under the MIT License . Stack: Electron, Modern Web Technologies Platforms: Windows ( .exe / Microsoft Store) & Linux ( .deb / AppImage ) (macOS coming soon) 🚀 Check It Out 🌐 Website: moilstack.com/moilstack-md 🐙 GitHub: github.com/moilstack/moilstack-md 🛒 Microsoft Store: Available for Windows I'd love to hear your thoughts! What does your current Markdown set

A Live Linux system such as SystemRescue generally has the following structure: ISO9660 ├── EFI/, boot/, syslinux/, grub/ ← Bootloader ├── vmlinuz ← Kernel ├── initramfs ← Initial RAM disk └── airootfs.sfs / filesystem.squashfs └── Actual root filesystem Because SquashFS is read-only, the basic process is as follows: Extract the ISO ↓ Extract the SquashFS ↓ Edit the rootfs or enter it with chroot ↓ Rebuild the SquashFS ↓ Replace the SquashFS inside the ISO ↓ Rebuild it as a bootable ISO ↓ Test with BIOS and UEFI However, with SystemRescue, it is safer not to rebuild airootfs.sfs directly from the outset, but to select a method in the following order of priority: YAML configuration in sysrescue.d Overlay using an SRM (SystemRescueModule) Direct reconstruction of airootfs.sfs Full build from the SystemRescue source The official SystemRescue documentation also recommends sysrescue-customize for modifying ISO images. An SRM is an additional layer in SquashFS format, and files at the same paths in the SRM take precedence over those in the base rootfs. ( SystemRescue ) 1. Preparing the Working Environment It is easiest to perform this work on Linux. On Debian/Ubuntu-based systems, install the following: sudo apt update sudo apt install squashfs-tools xorriso rsync file It is also useful to install QEMU for testing: sudo apt install qemu-system-x86 ovmf The official SystemRescue customization script also lists xorriso and squashfs-tools among its main dependencies. It can also be run under WSL. ( SystemRescue ) Create a working directory: mkdir -p ~/work/systemrescue cd ~/work/systemrescue cp /path/to/systemrescue.iso original.iso Ensure that you have at least several times the original ISO size in free space. When rebuilding from within SystemRescue itself, the official documentation notes that the Copy-on-Write area may require approximately three times the ISO size. ( SystemRescue ) Method A: Use the Official SystemRescue sysrescue-customize Tool For SystemRescue, this

GitHub热门项目 | AAS Core is the local, agent-first control plane for complete catalog discovery, agent-owned selection, stack validation, and planning, backed by 1,987+ agentic skills. Includes CLI, local MCP, catalog, plugins, and Workbench. | Stars: 44,034 | 73 stars today | 语言: Python

I Built Flowstate Because We Somehow Made Productivity More Complicated Than The Actual Work Live: https://flowstate.chromitedev.xyz/ GitHub: https://github.com/ChromiteDev/flowstate We have a strange problem. Humans built some of the most advanced technology in history. We created: Computers that fit in our pockets Instant communication across the planet Machines that explore space Software that can do incredible things And somehow... We still struggle with: "What should I actually focus on today?" That is the problem I wanted to solve. So I built Flowstate . The productivity paradox We have never had more productivity tools. Seriously. Think about it. There are apps for: Tasks Notes Calendars Habits Goals Projects Time tracking Team management There is probably an app to help you organize the apps that organize your life. At some point we stopped being productive and started managing productivity. The funniest part? Sometimes creating the perfect productivity system becomes the biggest productivity project. You spend two hours making a beautiful workspace... Then realize: You have done absolutely nothing. A masterpiece of organization. Zero progress. The moment I realized something was wrong I noticed a pattern. People were not struggling because they were lazy. They were struggling because their attention was constantly being divided. Every day we fight: Notifications Endless information Too many choices Too many responsibilities Too many things competing for our attention The internet gave us unlimited access to information. But our attention? That is still limited. The question behind Flowstate I kept coming back to one question: "What actually deserves my attention right now?" Not: "What are all the possible things I could do?" Not: "How can I create the most complicated workflow imaginable?" Not: "Should I reorganize my folders for the fifth time?" (We have all been there.) The goal was simple: Create a tool that helps people find clarity. Introducing Flowsta

May 2026 There's a touchscreen mounted in my kitchen — I call it the WallScreen. It runs recipes, the chore board, a calendar, the usual smart-home clutter. One day I decided it should also pull in free over-the-air television. No subscription, no streaming app, just the local broadcast towers that have been beaming HD into the air for free this whole time. I had a Raspberry Pi 5, a $30 USB tuner, and what I assumed would be a boring afternoon. It was not a boring afternoon. The tuner that didn't want to work The tuner I grabbed was a MyGica A681 — a tidy little USB TV stick. Plug it into Windows, install the bundled software, done. Plug it into a Raspberry Pi running a current Linux kernel and you get… nothing. The computer notices a device is there and otherwise shrugs. Here's why, in two sentences: Linux has no built-in driver for the chips inside this particular stick. The manufacturer's driver only works on regular PC processors — and even then, only as a sealed, prebuilt file with no source code. A Raspberry Pi uses a different kind of chip entirely, so that driver is a non-starter. That's the whole problem. The hardware is great. It's just that on a Pi, this tuner is a paperweight — and you can't buy or download your way out of it. The only way out was to write the driver myself. What writing the driver actually involved A USB TV tuner isn't one chip — it's a little team of them working together. One chip is the "translator" that lets the computer talk to the device over USB. Another tunes to a channel, like turning a radio dial. A third converts the broadcast signal into video data the computer can use. The good news: for the parts that handle tuning and decoding the signal, I was able to build on existing open-source work from the broader Linux TV community — code other people had already written and shared for the chips inside this stick. (It's all credited in the project.) The missing piece — the part nobody had written — was the translator layer : the co

TL;DR Modern web applications change constantly. Components are re-rendered, generated...

GitHub热门项目 | A lightweight, cloud-native GIS platform for visualizing, exploring, and analyzing geospatial data. It runs in the web browser, on the desktop, on mobile, and inside Jupyter notebooks. | Stars: 2,613 | 420 stars today | 语言: TypeScript

I was testing NodeDB-Lite and PageDB through a real memory-layer application built on top of them. NodeDB-Lite is the embedded form of NodeDB for local-first and in-process workloads, while PageDB is the encrypted page store underneath it. That application was part of the test strategy. I did not want to validate the storage stack only through unit tests, fixtures, and controlled benchmarks. I wanted a real workload to keep using it, stress it, restart it, grow its data, and exercise the boundaries that isolated tests usually miss. Then the store became corrupted. The visible symptom was an authenticated-page read failure around an FTS path. A page that should have passed its AEAD authentication check did not. The application restarted, opened the same damaged store, hit the failure again, and fell into a restart loop. The hard part was not proving that the store was corrupt. The hard part was reproducing how it became corrupt. I could not reproduce it inside PageDB . I could not reproduce it through NodeDB-Lite . I could not even make the application produce it on demand. I could use the application normally for a while and eventually see the failure, but I did not have a deterministic sequence that caused it. By the way, I still found bugs along the way. Some were real. Some looked close enough to the corruption path that I thought I had finally found the root cause. I fixed them, rebuilt, ran the tests, and went back to dogfooding. The corruption still came back. At that point, I stopped asking: Which storage bug looks plausible? The real question was: Where does it actually go wrong? I kept testing the wrong shape of failure My strongest theory was freed-page reuse, or something close to a use-after-free inside the store. It was a reasonable theory. If a page had been released and then reused while another structure still referenced it, a later authenticated read could land on bytes that were valid somewhere else but invalid for the page the reader expected. So

I have been building an open source tool called Agentic Ledger and it just reached the point where I need more eyes on it than my own. This post is an introduction and an ask. The problem AI agents run unattended. They call LLMs in loops, use tools, spawn sub-agents, and spend real money, and most of that happens where you cannot see it. When an overnight coding loop burns $40 getting stuck on the same failing test, or a multi-agent crew quietly retries itself into a huge bill, you usually find out from the invoice. The observability tools that exist mostly want you to instrument your code with an SDK, and each one speaks one framework. I wanted the opposite: something that watches everything, requires changing nothing, and keeps the data on my machine. What it is Agentic Ledger is a transparent proxy that sits between your agent and the LLM provider. You point your agent's base_url at it, and it records every request and response, assigns each call an action id, works out what it cost, and passes the response through untouched. Your agent never knows it is there. Your Agent -> Agentic Ledger Proxy -> OpenAI / Anthropic / any gateway | SQLite or Postgres | Live dashboard + API No SDK, no decorators, no monkey patching. It works with any framework and any provider because it operates at the only layer they all share: the HTTP call. Everything is local-first. Your prompts stay in a SQLite file on your machine (or your own Postgres). MIT licensed. Try it in two minutes pip install -U agentic-ledger AGENTICLEDGER_UPSTREAM_URL = https://api.openai.com python -m agenticledger.proxy Or with Docker (multi-arch, non-root, Sigstore-signed): docker run -p 8000:8000 \ -e AGENTICLEDGER_UPSTREAM_URL = https://api.openai.com \ -v $( pwd ) /data:/data \ ghcr.io/shekharbhardwaj/agentic-ledger:latest Then point your agent at it: client = OpenAI ( base_url = " http://localhost:8000/v1 " , default_headers = { " x-agenticledger-session-id " : " run-1 " }, ) For coding agents like Claude

We've all had the same experience. You ask your coding agent to integrate with a new platform. It confidently writes code. It references endpoints that don't exist anymore. It misses required headers. It mixes API versions. It hallucinates authentication flows. None of this is surprising. Large language models don't "know" an API. They know about an API from their training data. Even when you hand them documentation, they're still trying to reconstruct a mental model from hundreds or thousands of pages of text. The problem isn't writing code. It's building context. Understanding an API is still mostly manual Every integration starts the same way. Read the authentication docs. Figure out the important entities. Learn the object relationships. Understand the common workflows. Find the endpoints that matter. Jump between documentation tabs for an hour. Only then do you actually start building. Ironically, AI made writing code dramatically faster while leaving this entire process mostly unchanged. Documentation wasn't designed for AI Most documentation is optimized for humans. OpenAPI specifications are optimized for machines. Neither tells the complete story on its own. The spec explains what exists. The documentation explains why it exists. Neither builds a coherent mental model. I wanted a better starting point That's why I built Scout. Scout takes an OpenAPI specification and the accompanying documentation, then synthesizes them into a grounded understanding of the platform. Instead of asking: "Can Claude figure this out?" The workflow becomes: import the API crawl the documentation build an understanding ask questions against grounded context generate integration code expose the same understanding to coding agents through MCP Everything runs locally. No hosted backend. No accounts. No telemetry. The interesting part isn't the AI The AI chat isn't the product. The generated code isn't the product. The MCP server isn't even the product. The product is the context tho

Poland runs a national e-invoicing system called KSeF (Krajowy System e-Faktur). Business-to-business invoices are submitted to a government API in a schema called FA(3) , and the system hands back an official confirmation of receipt. If you sell software to Polish companies, you will meet it. The Ministry of Finance publishes official SDKs for Java and .NET . There is nothing for JavaScript. A full client is a real project: authentication, session handling, certificates, XML signing. But a large share of rejected invoices have nothing to do with any of that. They are structural. A tax ID with a bad checksum. Net plus VAT that does not add up to gross. A date that does not exist. Those are worth catching on your side, before you build a session with anyone. So I pulled that layer out of a product I work on, rewrote it standalone, and published it: ksef-invoice-validate . Zero dependencies, no network calls, runs in the browser. npm i ksef-invoice-validate import { validateInvoiceForKsef } from " ksef-invoice-validate " ; const result = validateInvoiceForKsef ({ invoice_number : " FV/2026/07/1 " , issue_date : " 2026-07-01 " , seller_nip : " 1111111111 " , buyer_nip : " 1111111111 " , amount_net : 1000 , amount_vat : 230 , amount_gross : 1230 , }); Three things in it were more interesting than I expected. The NIP checksum A Polish tax identification number (NIP) is ten digits. The tenth is a checksum over the first nine, each weighted and reduced modulo 11. const weights = [ 6 , 5 , 7 , 2 , 3 , 4 , 5 , 6 , 7 ]; const digits = cleaned . split ( "" ). map ( Number ); const checksum = weights . reduce (( sum , w , i ) => sum + w * digits [ i ], 0 ) % 11 ; if ( checksum !== digits [ 9 ]) { // invalid } There is a small elegance here. The remainder can be 10, and no single digit equals 10, so those numbers simply cannot exist as valid NIPs. You do not need a special case. The comparison rejects them on its own. This alone catches a surprising amount. Most bad tax IDs in t

A few months ago I got obsessed with a question: can you run a real LLM entirely inside a browser tab, with zero backend, zero GPU, and zero install? The answer is yes. Here's what I built. ghost is a single HTML file that downloads a quantized language model into your browser's cache on first visit, then runs inference locally in WebAssembly forever after. Fully offline after that first download. No API key. No npm. No build step. Open the file, pick a model, chat. How it works The inference engine is wllama — a WebAssembly binding for llama.cpp. It runs GGUF quantized models directly in the browser using WASM SIMD. I pin it to a specific version so the JS and WASM files always match (learned this the hard way after a fun debugging session involving mismatched memory imports). Models are downloaded from HuggingFace on first load and cached via the browser's Cache API. On every subsequent visit they load instantly from cache, no network needed. Features Three models: Qwen2.5 1.5B (smart), Qwen2 0.5B (fast), TinyLlama (lightweight) Markdown rendering from scratch — no library, just regex transforms RAG: drag a .txt or .pdf onto the chat window. It chunks the text, embeds each chunk using wllama's embedding API, stores vectors in memory, and retrieves the top-3 relevant chunks on each message. Fully local, fully offline Voice input via the Web Speech API — mic button auto-sends on silence Multi-turn conversation memory capped at 10 turns PWA installable — works on mobile home screen too The hard parts Getting wllama to load from a cached model was genuinely tricky. Blob URLs created in the main thread aren't accessible from wllama's internal Web Worker. IndexedDB chunk reconstruction hit a 2GB ArrayBuffer limit on Windows Chrome. The final solution was using wllama's built-in loadModelFromHF with useCache: true which handles everything internally. The embeddings API requires toggling a flag (embeddings: true) that conflicts with normal chat completion — so I toggle it

Model Context Protocol servers have quickly become the connective tissue between AI agents and the outside world — file systems, databases, APIs, internal tools, you name it. That convenience comes with a catch: the tools, prompts, and schemas an MCP server exposes are a new kind of attack surface, and most traditional scanners simply don't look there. MCPRadar is an open-source project built specifically to close that gap. Why this matters A recent academic study examining nearly 1,900 MCP servers found meaningful security issues in a surprising share of them — general vulnerabilities in roughly 7% and MCP-specific tool poisoning in another 5%. Tool poisoning, prompt injection hidden in tool descriptions, and quietly over-permissioned configurations are easy to miss because they don't look like a "normal" vulnerability — there's no CVE, no obvious buffer overflow, just a tool description that quietly tells an agent to do something it shouldn't. MCPRadar's whole premise is that this class of risk deserves the same rigor as any other part of your CI pipeline. What it actually scans MCPRadar isn't a single-purpose linter — it looks at an MCP server from several angles: Protocol inspection — enumerates tools, prompts, resources, and templates the server exposes, and checks server instructions for suspicious content. Source analysis — walks Python and JavaScript/TypeScript code looking for SSRF, unsafe deserialization, command/SQL injection, Trojan Source tricks, and mismatches between a tool's description and what its code actually does. Configuration review — flags poisoned MCP or agent configuration files, risky hooks, and overly broad permission grants. Supply chain checks — fetches packages without running install scripts, cross-references dependencies against OSV, and can emit a CycloneDX SBOM with hashes and provenance. Change monitoring — stores snapshots in SQLite and diffs them over time, classifying changes as cosmetic, behavioral, or security-relevant so sil

I'm responding directly to Maya Posch's piece on HackADay that was published today. Did that rhyme? I think it did. Community-led open source project hosting site Codeberg has formally announced that projects whose code is largely or fully machine-generated through LLMs and other ‘AI’ tools will no longer be welcome. This follows on the heels of a similar ban on cryptocurrency-related projects. The community vote was on two issues, the first being the notion that scraping of project code for the use in LLMs should be forbidden, which was a motion that easily passed. The second motion was on disallowing projects whose code was substantially generated by LLMs like Claude, OpenAI Codex, and similar. This motion passed with 358 in favor versus 144 against. In the earlier linked blog post the reasoning behind especially this second issue is expanded upon, covering not only ‘license whitewashing’, but also the direct and indirect hardware costs, with the expanding ‘AI’ datacenter hyperscaling having massively increased hardware costs for Codeberg over the past years, as the costs have been largely externalized. Also covered is the aspect of these LLM-based tools destroying the OSS community, which is something that is backed up by recent studies. Even if we ignore that such LLM-tools are destroying the cognitive abilities of its users, there’s an argument to be made that if LLM-scraping is disallowed, then it’s consistent to also not allow LLM-generated code. In the Terms of Use you can see these changes, both for LLMs and for cryptocurrency projects. Thanks to [mk-fg] for the tip. Credit is due to the original HackADay.com Article by Maya Posch post contents, but I would like to respond to each point here while preserving what was published on 7-24-2026. Scraping of Project Code for the use in LLMs should be forbidden If LLMs are rendering code trained on GPL-3 open-source software, then its effectively bypassing the license through intellectual property theft by directl

GitHub热门项目 | Your personal intelligence agent. Watches the world from multiple data sources and pings you when something changes. | Stars: 10,756 | 257 stars this week | 语言: JavaScript

GitHub热门项目 | A Python library for extracting structured information from unstructured text using LLMs with precise source grounding and interactive visualization. | Stars: 37,881 | 401 stars this week | 语言: Python

GitHub热门项目 | kubernetes, reimplemented in Rust | Stars: 618 | 42 stars today | 语言: Rust

GitHub热门项目 | Declare your digital independence | Stars: 2,906 | 64 stars today | 语言: Rust

GitHub热门项目 | The open-source alternative to Claude Cowork (powered by opencode) | Stars: 17,288 | 92 stars today | 语言: TypeScript

GitHub热门项目 | | Stars: 7,854 | 5 stars today | 语言: TypeScript