标签：#pens

GitHub热门项目 | Rust GUI components for building fantastic cross-platform desktop application by using GPUI. | Stars: 13,942 | 199 stars today | 语言: Rust

GitHub热门项目 | Miles is an enterprise-facing reinforcement learning framework for LLM and VLM post-training, forked from and co-evolving with slime. | Stars: 2,469 | 55 stars today | 语言: Python

The decision between a free hosted AI coding server and a self-hosted stack is rarely about price. It is about three measurable variables: token burn per task, latency tolerance, and privacy surface. Teams that compare sticker prices pick wrong. Teams that measure these variables pick right most of the time. This guide provides a decision table, a token budget script, and a one-week audit workflow. The framework applies to any free AI coding tier. The examples use MonkeyCode, an open-source AI coding assistant whose free tier includes model access and a hosted server with a 10M token allowance at the time of writing. Quotas and model availability change, so verify the current limits before relying on them. Disclosure: This article was prepared as part of MonkeyCode's product outreach. Why Sticker Price Is the Wrong Variable Free sounds better than paid. It is not always cheaper. A free server that burns 40,000 tokens on a task a local model handles in 8,000 tokens costs more in time, context, and rework. The real unit of comparison is tokens per completed task, not dollars per month. Self-hosting has the same trap. A GPU that already sits in the office looks free. Add power, cooling, maintenance, and the engineer who keeps the stack alive, and the hourly cost becomes visible. The comparison needs one model that accounts for both sides. The Three Variables That Decide Token burn per task Refactors and test generation consume more tokens than single-file edits. The number varies by model, context length, and repository size. Most teams never measure it. That is the first mistake. A 10M allowance sounds large until a monorepo context window eats a meaningful slice of it on every request. Latency tolerance Interactive coding needs fast first-token time. Batch tasks like code review or documentation generation tolerate seconds of delay. A free hosted server usually sits between the two. Teams that treat all tasks as interactive overestimate latency risk. Teams that treat

At 2:47 AM, the email lands: "Your free allowance expires in 72 hours. Upgrade to continue." Your demo works. Your eval harness passes. Your CI pipeline is green. And in three days, every one of those things will be a pile of 429s. I've been on both sides of this. I've built on free tiers that disappeared without notice, and I've watched teams scramble to migrate after the fact. The scramble is always the same: nobody knows which config file points at the remote endpoint, nobody remembers the local model weights were never downloaded, and the "quick fix" takes a full day. So I did the thing I should have done months ago. I ran an exit drill. Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode is an open-source AI development platform that currently offers a free managed server with a 10M-token allowance. The drill below works against any managed endpoint — MonkeyCode's free server is just a convenient target because the same codebase is self-hostable. The drill: 45 minutes, one laptop, zero meetings The goal is brutal and specific: make the application work without the free server, in under an hour, with only the tools already on your machine. I picked a Friday afternoon. I set a timer. I closed Slack. Here's exactly what happened. Minutes 0–5: Inventory the dependency The first step is finding every place your code touches the remote endpoint. Don't grep for the URL — grep for the client library. grep -rn "openai \| anthropic \| chat/completions" --include = "*.py" --include = "*.ts" --include = "*.js" . In my case, the damage was contained: one config file, two modules, and a test fixture that hardcoded the remote URL. The fix was a single environment variable. But knowing that took five minutes of grepping, not thirty seconds of intuition. The lesson: if your endpoint URL lives in more than one file, you've already failed the drill. It should be an environment variable, period. Minutes 5–15: Stand up the local replacement Th

RustDesk is gaining attention today with +84 GitHub stars , and the reason is straightforward: it provides an open-source remote desktop experience while allowing teams to control the infrastructure behind it. Unlike a client-only tool, RustDesk is built around a self-hosting model. The desktop client connects through a RustDesk ID server ( hbbs ) for rendezvous and a relay server ( hbbr ) when direct peer-to-peer connectivity is unavailable. This separation makes the architecture easier to reason about and gives operators more control over traffic and metadata. A quick server experiment can start with Docker: docker run -d \ --name rustdesk-hbbs \ --network host \ -v " $PWD /rustdesk-data:/root" \ rustdesk/rustdesk-server:latest \ hbbs docker run -d \ --name rustdesk-hbbr \ --network host \ -v " $PWD /rustdesk-data:/root" \ rustdesk/rustdesk-server:latest \ hbbr For production, configure the client with your server’s public key and hostname rather than relying on default discovery. Keep the relay and rendezvous ports documented, restrict administrative access, and store the generated keys in a protected location. The Rust implementation is a practical fit for a latency-sensitive desktop application: native binaries, low runtime overhead, and broad platform support. The trade-off is operational complexity. Self-hosting means handling updates, firewall rules, TLS or tunnel termination, backups, and monitoring yourself. Things to watch before production: Network design: Direct connections may fail behind strict NAT, forcing traffic through the relay and increasing bandwidth usage. Security controls: Treat the server key, access credentials, and client distribution process as sensitive infrastructure. Upgrade testing: Validate client/server compatibility in a staging environment before rolling out updates widely. For developers who want remote support without surrendering control of the entire connection path, RustDesk is a compelling open-source project to test in a p

Have you ever wondered how your smartwatch actually knows you're stressed? Most of us treat the "Stress Score" on our wrists as a source of truth, but the logic remains hidden behind proprietary algorithms. Today, we are pulling back the curtain. We are going beyond basic heart rate tracking to perform PPG signal processing and HRV frequency domain analysis using Python. By the end of this guide, you’ll know how to ingest raw data via Bluetooth Low Energy (BLE) , apply digital filters with SciPy , and calculate the elusive LF/HF ratio to determine autonomic nervous system balance. If you are interested in advanced biometric algorithms or Python signal analysis , you’re in the right place. 🚀 The Architecture: From Photons to Stress Metrics Unlike standard heart rate (BPM), which just counts peaks, Stress Scores rely on Heart Rate Variability (HRV) —the millisecond-level variations between heartbeats. We'll be moving from raw light intensity data to a frequency-based stress index. graph TD A[Wearable Sensor / PPG] -->|Raw BLE Stream| B[Data Acquisition - Bleak] B --> C[Preprocessing - Bandpass Filter] C --> D[Peak Detection - Find R-R Intervals] D --> E[Cubic Spline Interpolation] E --> F[Fast Fourier Transform - FFT] F --> G[LF/HF Ratio Calculation] G --> H[Final Stress Score] 🛠 Prerequisites To follow this advanced tutorial, you’ll need: Hardware : A pulse oximeter or wearable that exposes raw PPG via BLE (e.g., Polar OH1, MAX30102 with an ESP32). Stack : NumPy & SciPy : For heavy-duty math and signal processing. Bleak : For cross-platform Bluetooth Low Energy communication. Matplotlib : To visualize the pulse waves. Step 1: Capturing the Raw PPG Stream (BLE) Photoplethysmography (PPG) works by shining green or red light into the skin and measuring the light absorption. First, let's grab that raw stream. import asyncio from bleak import BleakClient # UUID for the Raw PPG Characteristic (Device specific) PPG_CHAR_UUID = " 00002a37-0000-1000-8000-00805f9b34fb " def no

GitHub热门项目 | Algorithm powering the For You feed on X | Stars: 32,574 | 37 stars today | 语言: Rust

Two instructions went into an Auditor my agent collaborators and I built to surface conflicts in...

Enterprise resource planning has traditionally been associated with large vendors, complex implementations, long contracts, and significant licensing investments. For decades, companies evaluating ERP systems were likely to encounter names such as SAP, Oracle, Microsoft Dynamics, and other established commercial platforms. That model is not disappearing. But the assumptions behind it are changing. In 2026, enterprises have more choices than simply selecting between competing proprietary ERP vendors. Open-source platforms such as ERPNext, Odoo, and other business application ecosystems have become credible alternatives for organizations that want greater control over their software, more flexible customization, and different approaches to total cost of ownership. At the same time, SaaS pricing, vendor lock-in, integration complexity, cloud adoption, data ownership, and increasingly capable development tools are changing how businesses think about enterprise software. This does not mean open-source ERP is automatically better. It means the ERP decision deserves to be reconsidered. The question is no longer simply: Which ERP vendor should we buy from? Increasingly, organizations are asking: How much control should we retain over the software that runs our business? What Is Open-Source ERP? Open-source ERP is enterprise resource planning software whose source code is made available under an open-source license that grants defined rights to use, inspect, modify, and distribute the software. The practical implications depend heavily on the specific project's license. For an enterprise buyer, however, the important distinction is that open-source software can provide a level of visibility and extensibility that proprietary software may not. A simplified comparison looks like this: Proprietary ERP Business │ ▼ Vendor Software │ ├── Vendor controls source ├── Vendor controls roadmap ├── Vendor controls licensing └── Vendor controls many upgrade decisions Open-Source ERP Busi

zarazhangrui/follow-builders is gaining attention for a simple reason: it focuses on the people building AI systems, not just the influencers discussing them. With 84 new stars today, the project is positioned as an AI builders digest that monitors notable creators across X and YouTube podcasts, then remixes their ideas into shorter, easier-to-scan summaries. That workflow addresses a real productivity problem. AI research and engineering conversations are scattered across long videos, fast-moving social feeds, and repeated announcements. A focused digest can reduce the time spent collecting links while preserving the practical signal: architectural decisions, implementation lessons, tools, and emerging patterns. A sensible first step is to inspect the repository locally before deciding how deeply it fits your workflow: git clone https://github.com/zarazhangrui/follow-builders.git cd follow-builders # Inspect the setup instructions and available scripts ls -la find . -maxdepth 2 -type f | sort | head -80 For an AI-assisted workflow, I would pair the project with a small review loop: Collect the generated digest. Extract claims, links, and mentioned tools. Open the original source before acting on important technical advice. Save durable findings in a project notes file or knowledge base. This keeps summaries useful without treating them as authoritative research. It also makes the tool a good companion for developers using Cursor or another AI IDE: the digest supplies discovery, while the IDE helps turn validated ideas into experiments and code. Before production use, watch for two trade-offs: Summary fidelity: compressed content can lose context, caveats, or disagreements from the original conversation. Source coverage: ranking “top builders” may introduce selection bias, so important perspectives can be missed. The strongest use case is not replacing primary sources. It is building a high-signal starting queue for developers who want to follow AI progress without

When businesses outgrow spreadsheets and disconnected SaaS tools, the next question is often whether they should buy another application, customize an existing platform, or build a system specifically around their workflows. For many organizations, building custom business software can appear expensive and technically demanding. A development team has to think about authentication, permissions, database models, APIs, user interfaces, background jobs, reporting, audit trails, and deployment. This is where open-source application frameworks can change the equation. Instead of building every foundational capability from scratch, a framework can provide the underlying architecture while developers focus their effort on the business problems that actually differentiate the organization. One example is the Frappe Framework , an open-source web application framework used to build business applications such as ERPNext. But what exactly is Frappe, and why would an organization consider using it for custom enterprise software? What Is Frappe Framework? Frappe is an open-source, Python- and JavaScript-based web application framework designed to make it easier to build database-driven business applications. Rather than being simply a collection of programming utilities, Frappe provides a broader application foundation. It includes capabilities for: Data modeling Authentication Role-based permissions REST APIs Web forms Background jobs Reporting Workflow management Notifications File attachments Activity and audit information User interfaces Database access Application configuration This means a development team can start with an application architecture that already understands many of the requirements common to business software. The important distinction is this: Frappe is a framework for building applications. ERPNext is an application built using that framework. That distinction matters when evaluating Frappe for custom software development. Frappe vs ERPNext Frappe and ERP

OpenHabitTracker is a free, open source habit tracker that also holds your notes and tasks. It runs on Windows, Linux, macOS, iOS, Android and in a browser, with no ads and no account. Filtering and sorting habits A habit here is not measured by a streak. It is measured by how much of its interval has gone by. A habit you want to do every ten days, two days late, is at 120%. A habit you want to do every four days, also two days late, is at 150%. Because that is a number, you can filter on a range of it: only habits above 50%, only habits below 150%, or only the ones in between. That last one is everything neither freshly done nor badly overdue. You can sort by it as well, and the sort takes the repeat count into account, so a habit done three times a day and one done weekly are compared against each other rather than the daily ones always sitting on top. There are other ways to sort habits by time: how long you want between repeats, how long it has actually been averaging, how long since the last one, and how much time you have spent on it in total or per completion. Notes and tasks sort by the plain things, category, priority and title, and tasks also by their planned date and duration. Each of the three keeps its own sort order. Filtering by date Tasks have a planned date. Tasks and habits have the dates they were completed on. Both are filtered separately, each before, on, after or not on a date you pick. A filter can also take a number of days from today instead of a date. Minus seven to plus seven is the week either side of now, and it still means that in a month, because the days are counted at the moment you look rather than the moment you set it. Showing what was not done The completed-date filter has a switch next to it. Turned on, the range shows what you finished in those days. Turned off, the same range shows what you did not. Searching notes, tasks and habits Searching a note searches the whole note, not just its title. Searching tasks and habits search

FSCSS component architecture is built around a modular, composition-first model that compiles to plain CSS. It emphasizes reusable style units, design tokens, conditional logic, and selective imports—with almost no runtime JavaScript required for the final output. Components in FSCSS are treated as pure style definitions rather than framework-specific widgets, keeping stylesheets readable, highly reusable, and free of classic “mega-stylesheet” problems while still producing standard CSS that any browser understands. Core Building Blocks FSCSS provides a focused set of primitives for defining and composing styles: Primitive Purpose Best for Introduced / Key version str(name, "…") Named blocks of CSS declarations Simple reusable style snippets Core @fun(name){…} Key-value stores (design tokens) Spacing scales, color palettes, property groups Core @define name(params) Parameterized mixins Themed components, variants, full structures 1.1.15+ pattern(threshold: "desc", "…") Semantic / fuzzy matching Natural-language style injection 1.1.25+ @event name(param) Conditional value functions Themes, states, calculations Core @arr(name[…]) Arrays + iteration Generated classes, loops, scales Core @import Selective / wildcard module loading Modular architecture & ecosystem modules Core How Components Are Structured 1. Atomic / Token Layer ( @fun + variables) Design tokens sit at the foundation so every component draws from a single source of truth: @fun(tokens) { primary: #2563eb; radius-md: 8px; space-4: 1rem; shadow-sm: 0 1px 3px rgba(0,0,0,.1); } 2. Base Style Blocks ( str() or @fun full-block) Related declarations are grouped into reusable blocks that can be dropped into any selector: str(card-base, " padding: @fun.tokens.space-4.value; border-radius: @fun.tokens.radius-md.value; box-shadow: @fun.tokens.shadow-sm.value; background: white; ") 3. Parameterized Components ( @define ) True mixins accept arguments and can be composed freely: @define button(bg: #2563eb, fg: white,

Design engineers increasingly work across two systems: the visual language of a product and the implementation details that make it usable. Skills for Design Engineers from ibelick focuses on that overlap, packaging practical guidance for building interfaces with stronger visual quality, clearer interaction patterns, and more consistent engineering decisions. The project is attracting attention, with +46 stars today . That momentum makes sense: design-focused AI workflows are moving quickly, but many generated interfaces still need human judgment around spacing, typography, responsive behavior, accessibility, and component reuse. The useful way to approach this project is not as a drop-in framework. Treat it as a reference layer for your development workflow. Read the relevant skill instructions, adapt them to your stack, and keep the resulting guidance close to the codebase so it can be applied consistently during implementation and review. A lightweight local setup might look like this: mkdir -p .ai/skills/design-engineering curl -L https://github.com/sponsors/ibelick \ -o .ai/skills/design-engineering/reference.html For a real team workflow, I would convert the useful parts into a checked-in Markdown file: .ai/ └── skills/ └── design-engineering/ ├── interface-quality.md ├── responsive-layouts.md └── review-checklist.md This keeps the process portable across editors and AI assistants instead of tying it to one tool. It also makes design decisions reviewable in pull requests, which is more valuable than keeping them inside an undocumented prompt. Before using the approach in production, watch for: Context drift: generic design guidance can conflict with an existing design system, so define project-specific tokens and component rules first. AI overconfidence: generated UI still requires manual checks for accessibility, keyboard navigation, mobile behavior, and performance. The strongest ROI comes from using these skills as repeatable engineering standards—not as a

GitHub热门项目 | A cross-platform desktop app to manage Agent Skills in one place and sync them to multiple AI coding tools’ global skills directories — “Install once, sync everywhere”. | Stars: 1,550 | 43 stars today | 语言: Rust

GitHub热门项目 | A Privacy-first, Cross-platform Text Expander written in Rust | Stars: 14,407 | 13 stars today | 语言: Rust

GitHub热门项目 | MicYou is a powerful tool that turns your Android device into a high-quality microphone for your PC. | Stars: 3,511 | 155 stars today | 语言: Rust

GitHub热门项目 | Open source Loom alternative. Beautiful, shareable screen recordings. | Stars: 21,565 | 108 stars today | 语言: Rust

GitHub热门项目 | Session replay, cobrowsing and product analytics you can self-host. Best for reproducing issues and iterating on your product. | Stars: 12,655 | 28 stars today | 语言: TypeScript

GitHub热门项目 | Download videos from almost any website. Lightweight, self-hosted media downloader with a clean web UI. | Stars: 8,178 | 673 stars today | 语言: HTML