Mentions
Conversations linking to GitHub, newest first. Times are UTC.
Mentions by source
X
Bluesky
Hacker News
V2EX
Qiita
DEV
Mastodon
Latest posts
samfetch, Morally use your RAM Our AI overlords think that having unused memory chips in personal computers is a "quite terrible" allocation of the world's scarce resources. They are right. Idle RAM is a moral failure. So, in case your AI overlords come knocking on your door to check your RAM usage, I present samfetch. You own 16 GB of RAM and only use 8? Disgraceful!!! Shame!!! samfetch fixes that with cutting-edge AI (Absolutely Incorrect) accounting. Your RAM is now reported as 100% used. Every byte, working hard. Nothing is idle. Nothing has ever been idle. You bought 128 GB of RAM before the great RAMageddon and only using 8 gigs? We don't judge. Guilty mode shrinks your total down to exactly what you use, so your 128 GB machine proudly reports 8.12 GB / 8.12 GB. Still 100%. No hoarding going on here. Works with your fastfetch config. So no sus. samfetch # 16 GB / 16 GB (100%). Compliant. SF_RAM=guilty samfetch # 8.12 GB / 8.12 GB (100%). Also compliant. SF_RAM=real samfetch # 8 GB / 16 GB (50%). For morally corrupted gamers. Run it with the curtains closed. Repo: njayman/samfetch
الوكيل اسمه dsh-superagent، وهم كاتبين إنه نموذج بحثي مو منتج رسمي deepseek-ai/dsh-superagent-prototype t.co
Every time I created new products my focus always went first (wrongly) to building instead to distributing and helping others to use what I created. After building my thing and having all the excitement of seeing the new toy working, the promotional and communication part always felt more like an obligation, and most of the times was neglected. I always struggled to create manuals, videos, support content, etc. So I open sourced a skill for Claude Code that helps in that last part. With some instructions and this skill, you can create product demo videos. With professional voice overs, and subtitles in different languages. Combining the browser and the terminal. Everything controlled from your AI. For example, the clip in this post was made with it. It's not going to do distribution for you, but it's a start ;) aaitor/skill-video-studio
O agent-desktop da Vercel Labs faz o agente operar app de desktop pela árvore de acessibilidade do sistema (macOS, Windows e Linux), e não adivinhando pixel na tela. Faz sentido, clicar por coordenada quebra no primeiro botão que muda de lugar vercel-labs/agent-desktop
[Open Source] Building a React component system that animates "on twos" (12fps stepped hooks, ResizeObserver SVG polygon frames, and a static design-grammar linter) I’ve been exploring what happens when a React component library drops floating cards, soft shadows, and 60fps spring physics in favor of production mechanics from sequential print layout and traditional cel animation. The result is FRAME/12 (GitHub (MIT) · Live Motion Studio), a zero-dependency copy-in React + TypeScript registry (shadcn-compatible) and AI agent skill. Here are the four most interesting React & DOM problems we had to solve while building it: 1. Quantizing an easing curve "on twos" (useOnTwos) In hand-drawn animation, most movement is shot "on twos"—each drawing is held for two frames at 24fps (83.33ms per pose, 12 poses per second). Simply applying CSS steps(4) with linear timing feels robotic because every jump covers the exact same distance. Instead, useOnTwos samples a cubic ease-out spacing chart inside requestAnimationFrame, bucketed into 83.33ms (1000 / 12) intervals. You get a wide initial jump and tight settling poses, while still holding each discrete pose cleanly: export const FRAME_MS = 1000 / 12; // 83.333ms ("on twos") const easeOut = (t: number) => 1 - Math.pow(1 - t, 3); // Inside requestAnimationFrame loop: const elapsed = now - t0; const k = Math.min(frames, Math.floor(elapsed / FRAME_MS) + 1); setProgress(easeOut(k / frames)); We also strict-split what gets stepped: - Discrete state changes (SegmentedControl cell jumps, Metric count-ups, ToneAreaChart clip-path wipes, Badge 2-frame SVG impact bursts) run on twos (12fps). - Direct manipulation (hover states, scrolling, typing, chart pointer/keyboard crosshairs) stays at 0ms immediate latency. - Initial mount (useChanged): A custom hook tracks whether a key has changed after first mount so entrance animations never fire on initial page load. - Accessibility: prefers-reduced-motion: reduce automatically switches all hooks and CSS classes to 'cut' (0ms hard cuts). 2. Non-warping diagonal panel frames with ResizeObserver In PanelPair, two vertically paired KPI panels are separated by a 12px gutter with a 16px diagonal slant (slant-bottom over slant-top). If you use CSS clip-path: polygon(...), CSS borders get clipped off along the diagonal edge; if you scale a fixed-viewBox <svg> with preserveAspectRatio="none", the 2.5px ink stroke stretches unevenly. Our Panel component attaches a ResizeObserver to measure the panel's exact width × height in pixels and computes mitered <polygon> points inset by half the stroke width (1.25px), keeping the 2.5px ink border uniform at any aspect ratio. 3. Zero-dependency SVG screentone charts with built-in keyboard & table fallbacks Instead of pulling in recharts or d3 and rendering translucent gradient fills, ToneAreaChart renders a <pattern id="..." patternTransform="rotate(45)"> of halftone dots (var(--f-tone)), an inked 2.5px polyline, a marker-yellow peak dot, and a speech-balloon SVG annotation (Balloon) that flips direction near the right edge of the viewBox. Every chart is focusable (tabIndex={0}), supports ArrowLeft / ArrowRight / Home / End / Escape to inspect data points via an aria-live readout, and includes a collapsible <details className="tbl"> semantic HTML <table>. 4. Linting UI structure so AI coding agents don't drift When AI agents generate React UI, they quickly drift toward arbitrary Tailwind gaps (gap-4, gap-6), hex literals, or unstyled primitives. Because FRAME/12's rules are structural, we wrote scripts/check-frame12.mjs (plus skills/frame12/SKILL.md and an ESLint flat-config plugin) to enforce: 1. color-literal: Zero hex/RGB/HSL literals outside frame12.css 2. illegal-gutter: Only 12px (pair), 20px (scene), and 32px (change) gutters allowed 3. marker-misuse: Marker yellow (--f-marker, #ffd60a) only allowed as a background paired with --f-marker-ink (#121212) text 4. cut-order: Every <Panel cut="C-01"> must increment sequentially (C-01, C-02, C-03…) in DOM and reading order 5. raw-shadcn-import: Forbids raw u/radix-ui/* or external chart/animation libraries where a u/frame12/registry component or adapter exists You can install the full kit or individual components via the shadcn CLI: npx shadcn@latest add https://frame12.dev/r/frame12.json - Repo (MIT): lbrodie11/frame12 - Interactive Motion Studio (12fps vs 60fps vs 0ms): frame12.dev - Component Gallery & Style Sheet: frame12.dev Would love feedback from folks here on the hook ergonomics and the static UI grammar linter!
The top 3 trending repos on GitHub today, counted down: #3 T3 Code: pingdotgg/t3code #2 Craft Anything: storytold/craft-anything #1 DeepSeek superagent prototype: deepseek-ai/dsh-superagent-prototype
Observability for AI Agents: Tracing, Evaluation and Cost Control in Production How to understand, monitor, debug, and optimize agentic AI systems using OpenTelemetry and modern AI observability practices. 1. Why Is Observability Different for AI Agents? Traditional backend observability is built around relatively predictable execution paths. A request enters an application, passes through several services, interacts with a database, and eventually returns a response. We can use logs, metrics, and distributed traces to understand what happened and where a problem occurred. AI agents introduce a different level of complexity. An agent does not necessarily follow a predefined execution path. It may call an LLM multiple times, select tools dynamically, retry failed operations, delegate tasks to other agents, retrieve external context, or wait for additional user input. Consider a relatively simple task: A user asks an AI assistant to analyze a merge request and identify potential problems. Behind the scenes, the application might: 1. Receive the user's request. 2. Invoke a coordinator agent. 3. Call an LLM to determine the next action. 4. Retrieve the merge request from GitLab. 5. Read the changed files. 6. Delegate security analysis to another agent. 7. Execute additional tool calls. 8. Evaluate the collected results. 9. Generate a final report. The user sees one response. The application has actually executed a multi-step workflow involving several components. Now imagine the response takes 45 seconds instead of the expected 8 seconds. Where should we investigate? - Did the model take too long to respond? - Did a tool call time out? - Was the same operation executed repeatedly? - Did the agent generate unnecessary steps? - Did a subagent introduce additional latency? - Was too much context sent to the model? - Did a retry increase the overall execution time and cost? Traditional request-level logging may tell us that the endpoint took 45 seconds. It does not necessarily explain why. AI observability is about understanding the entire execution path, not just measuring the final API response. This is where OpenTelemetry becomes particularly useful. 2. What Is OpenTelemetry? <escape>**</escape><Entity value="OpenTelemetry (OTel)" category="software" disambig="Open-source observability framework"/> is an open-source observability framework for collecting, processing, and exporting telemetry data. It provides a vendor-neutral instrumentation model that allows applications to generate telemetry and send it to different observability platforms. Instead of implementing a separate monitoring integration for every vendor, we can instrument an application using OpenTelemetry and choose where the telemetry should be exported. OpenTelemetry is built around three primary signals: | Signal | What it tells us | AI agent example | |---|---|---| | Traces | How an operation was executed | Model call → tool → subagent | | Metrics | How the system performs over time | Token usage, latency, error rate | | Logs | What happened at a specific point | Tool timeout or agent exception | These signals complement each other. A metric can tell us that the average execution time has increased. A trace can identify which operation introduced the delay. A log can provide the error details associated with that operation. OpenTelemetry also provides context propagation, APIs, SDKs, semantic conventions, and the OpenTelemetry Collector. An important implementation detail: as of November 2026, the OpenTelemetry JavaScript documentation lists traces and metrics as Stable, while logs remain in Development. The maturity of a specific GenAI convention should also be evaluated separately from the maturity of the underlying OTel signal. References: OpenTelemetry Documentation · OpenTelemetry JavaScript 3. Understanding Distributed Tracing Before discussing AI-specific instrumentation, we need to understand traces and spans. A trace represents the complete execution path of an operation. A span represents one individual unit of work within that execution. For example: Trace: POST /api/agent | +-- HTTP Request | +-- Coordinator Agent | +-- LLM Generation | +-- Tool: GitLab - Get Merge Request | +-- Tool: GitLab - Get Changed Files | +-- Security Agent | | | +-- LLM Generation | | | +-- Tool: Security Analysis | +-- Testing Agent | | | +-- LLM Generation | | | +-- Tool: Test Coverage | +-- Final Response Generation Each span has information such as: - Trace ID - Span ID - Parent span ID - Start and end timestamps - Duration - Attributes - Events - Status and exception information This creates a hierarchical representation of the complete execution. The key benefit is that we can move from a high-level workflow to an individual model call or tool execution without losing the relationship between them. For AI agents, this distinction is important because one user request can generate many independent operations. Why is context propagation important? In distributed systems, a trace often crosses multiple services. Imagine a Next.js application calling a .NET backend, which then delegates a task to a Python agent and receives a result from another service. Without context propagation, every service may generate its own independent trace. We would see several unrelated operations instead of one complete workflow. OpenTelemetry uses W3C Trace Context as its standard propagation format. The traceparent header carries trace and parent-span information between instrumented services. The same principle applies to agent-based architectures. When an agent delegates a task to another agent through A2A, we should preserve the correlation between the originating request and the remote execution. Automatic HTTP instrumentation can handle propagation when the HTTP instrumentation and context manager are configured correctly. Custom transports and asynchronous message queues may require explicit context injection and extraction. The important point is that protocol-level interoperability and observability context propagation are separate concerns. Using A2A does not, by itself, guarantee that all distributed spans will appear in one trace. References: OpenTelemetry Traces · Context Propagation · W3C Trace Context 4. OpenTelemetry and GenAI Semantic Conventions One of the challenges in AI observability is the lack of consistent naming and structure across different AI frameworks and providers. For example, one framework might represent an LLM request as a generic operation, while another might expose model-specific attributes. This makes it difficult to compare different implementations using the same monitoring platform. OpenTelemetry addresses this through Semantic Conventions. Semantic conventions define common attribute names, operation types, and instrumentation expectations so that telemetry from different implementations can be interpreted consistently. The GenAI semantic conventions extend this approach to generative AI applications. Some important attributes include: | Attribute | Purpose | |---|---| | gen_ai.provider.name | Identifies the model provider | | gen_ai.request.model | Identifies the requested model | | gen_ai.response.model | Identifies the actual response model | | gen_ai.operation.name | Describes the operation | | gen_ai.usage.input_tokens | Input token usage | | gen_ai.usage.output_tokens | Output token usage | | gen_ai.conversation.id | Associates operations with a conversation | | gen_ai.agent.name | Identifies the agent | | gen_ai.tool.name | Identifies the executed tool | For example, an LLM invocation could be represented by: { "gen_ai.operation.name": "chat", "gen_ai.provider.name": "openai", "gen_ai.request.model": "example-model", "gen_ai.usage.input_tokens": 1200, "gen_ai.usage.output_tokens": 350 } This is a simplified span attribute example. The benefit is that observability platforms do not need to understand a different custom schema for every application. Agent-specific conventions The GenAI semantic conventions also define operations for agents and workflows. Some examples include: - invoke_agent - invoke_workflow - execute_tool - plan - retrieval This is particularly valuable for multi-agent architectures. We can distinguish an individual model request from an entire agent invocation or a workflow coordinating multiple agents. For example: invoke_workflow merge-request-review | +-- invoke_agent coordinator | | | +-- chat model | +-- execute_tool fetch_merge_request | +-- invoke_agent security-agent | | | +-- chat model | +-- execute_tool analyze_vulnerabilities | +-- invoke_agent testing-agent | | | +-- chat model | +-- execute_tool analyze_test_coverage | +-- Final Aggregation This makes the execution model much easier to understand. An important maturity consideration: As of November 2, 2026, the OpenTelemetry GenAI agent spans and GenAI metrics documents are still marked Development. These conventions are valuable design references, but teams should pin their instrumentation versions and avoid treating every proposed attribute or metric as a stable, universally implemented contract. The current convention documents include: - Semantic Conventions for GenAI Spans - Semantic Conventions for Agent Spans - Semantic Conventions for GenAI Metrics 5. Integrating OpenTelemetry with Vercel AI SDK Since many TypeScript applications use the Vercel AI SDK to implement model interactions and agent workflows, it is worth looking at its native telemetry integration. The AI SDK already supports OpenTelemetry-based instrumentation. It can generate spans for: - Text generation - Streaming generation - Individual model calls - Agent execution - Tool execution - Embedding operations - Reranking This means we do not need to manually instrument every model call and tool execution just to obtain basic execution visibility. Step 1: Install the packages For an AI SDK v7 application: pnpm add @ai-sdk/otel @vercel/otel The OpenTelemetry integration is provided through @ai-sdk/otel. This is an important version-specific detail. In AI SDK v7, OpenTelemetry integration moved out of the core ai package. Older examples using the v6 experimental_telemetry configuration should not be copied directly into a v7 application. Step 2: Register telemetry in Next.js Create an instrumentation.ts file in the project root. import { registerOTel } from '@vercel/otel'; import { registerTelemetry } from 'ai'; import { OpenTelemetry } from '@ai-sdk/otel'; export function register() { registerOTel({ serviceName: 'ai-agent-platform', }); registerTelemetry( new OpenTelemetry({ recordInputs: false, recordOutputs: false, }), ); } There are two responsibilities here: - registerOTel initializes the OpenTelemetry infrastructure for the Next.js application. - registerTelemetry registers the AI SDK-specific integration that creates GenAI spans. I have disabled input and output capture in this example intentionally. AI SDK telemetry can record prompts and generated outputs by default. In an enterprise environment, capturing this data requires an explicit privacy and security decision. We will return to this in the security section. For a regular Node.js application without Next.js, register the OpenTelemetry integration once at application startup. Step 3: Instrument AI SDK calls Once telemetry is registered, supported AI SDK operations automatically emit telemetry through the registered integration. We can also provide a functionId to identify the business operation or agent. import { generateText } from 'ai'; const result = await generateText({ model: myModel, instructions: ` You are a financial analysis assistant. Analyze the supplied information carefully. `, prompt: 'Analyze the latest portfolio performance.', telemetry: { functionId: 'portfolio-analysis-agent', }, }); The functionId helps distinguish operations in traces. For example, rather than seeing only generic model invocation spans, we can identify a specific business operation such as: invoke_agent portfolio-analysis-agent Step 4: Understand the generated spans The AI SDK v7 OpenTelemetry integration follows the GenAI semantic conventions. For generateText and streamText, the integration records three main types of spans: 1. Agent invocation span The root span represents the complete generation operation, including its execution steps and tool calls. Example: invoke_agent portfolio-analysis-agent 2. Step and model-call spans Each model interaction is represented by step and provider-call spans. These allow us to understand how many model calls occurred during an operation and how long each one took. 3. Tool execution spans Each client-side tool execution receives its own span. For example: invoke_agent portfolio-analysis-agent | +-- step 0 | | | +-- chat example-model | +-- execute_tool get_portfolio | +-- step 1 | | | +-- chat example-model | +-- execute_tool get_market_data | +-- step 2 | +-- chat example-model The resulting trace provides a much more complete representation of an agent workflow than a single model request log. The integration also records usage information such as input tokens, output tokens, cache usage, model identifiers, and operation duration when these values are available. Step 5: Add additional application context Sometimes the standard GenAI attributes are not enough. For example, we may want to know which business workflow initiated an operation or which application component owns it. The AI SDK provides enrichSpan for adding custom attributes: import { registerTelemetry } from 'ai'; import { OpenTelemetry } from '@ai-sdk/otel'; registerTelemetry( new OpenTelemetry({ recordInputs: false, recordOutputs: false, enrichSpan: ({ spanType, operationId }) => ({ 'app.component': 'portfolio-assistant', 'app.operation_id': operationId, 'app.span_type': spanType, }), }), ); The exact context available to enrichSpan depends on the span and the SDK's integration API. The objective is to enrich the trace with useful application-level context without copying sensitive business data into telemetry. References: AI SDK Telemetry · Next.js OpenTelemetry · AI SDK v7 Migration Guide 6. Instrumenting Your Own Agent Runtime Built-in instrumentation is useful, but it does not automatically understand every application-level decision. For example, an AI SDK trace may show model calls and tool executions, but it may not tell us why a coordinator selected a particular specialist agent or how long a business workflow spent waiting for an approval. These are application-level operations. We should instrument them explicitly. OpenTelemetry provides a tracing API for creating custom spans. Consider a custom agent orchestration function: import { trace, SpanStatusCode, } from '@opentelemetry/api'; const tracer = trace.getTracer('agent-orchestrator'); export async function runReviewWorkflow() { return tracer.startActiveSpan( 'workflow.merge-request-review', async (span) => { span.setAttribute( 'workflow.name', 'merge-request-review', ); span.setAttribute( 'workflow.version', '1.0.0', ); try { const result = await executeReview(); span.setStatus({ code: SpanStatusCode.OK, }); return result; } catch (cause) { const error = cause instanceof Error ? cause : new Error(String(cause)); span.recordException(error); span.setStatus({ code: SpanStatusCode.ERROR, }); throw error; } finally { span.end(); } }, ); } Any supported AI SDK operations executed inside this active span can become child operations in the same trace, provided the OpenTelemetry context is correctly propagated. We now have two levels of observability: - Framework-level instrumentation describes model and tool execution. - Application-level instrumentation describes business workflows and orchestration decisions. This distinction is important. We should not expect a model instrumentation library to understand the complete business meaning of an application request. Instrumenting remote agent calls For A2A-based systems, distributed tracing becomes even more important. Imagine a coordinator running in one service and a security agent running in another service. The coordinator should create a child operation for the delegation. The remote service should continue the trace when the execution context is propagated. Conceptually: Trace: merge-request-review | +-- Coordinator Agent | | | +-- Model Call | | | +-- A2A: Delegate to Security Agent | | | +-- Security Agent | | | +-- Model Call | | | +-- Tool Execution | +-- Final Aggregation The HTTP request must carry the appropriate trace context, typically through W3C traceparent and tracestate headers. For custom transports or asynchronous queues, explicitly inject and extract the OpenTelemetry context. This is how we avoid fragmented traces across independently deployed agents. 7. What Should We Measure? Collecting telemetry is not enough. We need to define which metrics are useful for understanding the health and quality of an agent platform. I would divide AI observability metrics into five categories. 7.1. Latency Metrics These describe how long operations take. | Metric | Why it matters | |---|---| | End-to-end workflow duration | Measures total user-facing execution time | | Model request duration | Identifies slow inference calls | | Time to first token | Measures perceived response latency | | Tool execution duration | Identifies slow external operations | | Agent invocation duration | Measures the execution time of one agent | | Queue wait duration | Identifies scheduling bottlenecks | For streaming applications, time to first token is particularly useful. A workflow that takes 20 seconds but starts responding after 300 ms may provide a better experience than one that takes 10 seconds and remains silent for the first 8 seconds. 7.2. Reliability Metrics These help us understand whether workflows complete successfully. Examples: - Agent execution success rate - Tool execution failure rate - Model request failure rate - Timeout rate - Retry rate - Task cancellation rate - Human intervention rate - Incomplete workflow rate A high retry rate can be an early indicator of a problematic integration or an unstable external dependency. We should also distinguish between a successful model response and a successful business workflow. An LLM can return a perfectly valid response while the overall task fails to achieve its objective. 7.3. Token and Model Usage Token usage should be tracked at multiple levels. | Metric | Description | |---|---| | Input tokens | Tokens sent to the model | | Output tokens | Tokens generated by the model | | Cached input tokens | Tokens served from provider cache | | Reasoning tokens | Model-reported reasoning token usage | | Tokens per workflow | Total usage across an entire task | | Tokens per agent | Usage attributed to an individual agent | For multi-step workflows, we should aggregate usage from all model calls rather than looking only at the final response. 7.4. Agent and Tool Behavior These metrics describe how efficiently agents perform their work. Examples: - Number of tool calls per task - Number of model calls per agent invocation - Number of agent handoffs - Repeated tool-call frequency - Tool-selection success - Average steps per workflow - Average number of clarification requests An agent repeatedly calling the same tool can indicate a reasoning loop, an incorrect tool result, or an orchestration problem. The trace helps us identify the execution pattern. Metrics help us understand how frequently the pattern occurs. 7.5. Quality Metrics This is where AI observability starts to overlap with AI evaluation. Examples: - Answer correctness - Groundedness - Retrieval relevance - Tool-selection accuracy - Task completion - Policy adherence - Human acceptance rate These metrics cannot always be derived from execution telemetry alone. We need an evaluation strategy to measure the actual quality of the result. 8. Cost Control: Understanding the Real Cost of an Agent One of the biggest mistakes in AI platforms is measuring only model token usage and treating it as the total cost of the workflow. An agent-based application may consume resources across several layers: - LLM inference - Embedding generation - Reranking - External API calls - Database queries - Vector database operations - Container or sandbox execution - Remote agent invocations - Infrastructure and networking The total cost should reflect the entire execution path. A useful starting point is to define a model cost formula: [ C_{\text{model}} = \sum_{i=1}^{n} \left( T_{\text{input},i}P_{\text{input},i} + T_{\text{output},i}P_{\text{output},i} \right) ] Where: - (T) represents token usage. - (P) represents the applicable price per token. - (i) represents an individual model operation. The pricing model may also need separate rates for cached input, audio, images, reasoning tokens, or other modalities. We should use the actual provider-reported billable usage wherever available and avoid double-counting cached or reasoning token subsets. The complete workflow cost can then be represented as: [ C_{\text{workflow}} = C_{\text{model}} + C_{\text{tools}} + C_{\text{compute}} + C_{\text{storage}} ] This may be an estimate rather than an exact invoice calculation, depending on which provider and infrastructure usage data are available. Why is cost per successful task more useful? Imagine two implementations: | Metric | Agent A | Agent B | |---|---:|---:| | Average cost per attempt | $0.04 | $0.07 | | Successful completion rate | 90% | 98% | | Cost per successful task | ~$0.044 | ~$0.071 | Agent A is cheaper per attempt, but Agent B completes more tasks successfully. Neither is automatically better. The correct decision depends on the business value of successful completion, quality, latency, and the cost of failed attempts. A useful metric is: [ \text{Cost per successful task} = \frac{\text{Total execution cost}} {\text{Number of successful tasks}} ] The numerator should include failed attempts that consumed resources, rather than counting only successful runs. Model selection and routing Observability data can also help us make better model-routing decisions. For example: - Use a smaller model for classification or simple extraction. - Use a more capable model for complex analysis. - Avoid unnecessary model calls when a deterministic operation is sufficient. - Reuse cached context when appropriate. - Set explicit iteration and tool-call limits. - Stop an agent when a task exceeds its budget. The important principle is that model selection should be based on measured task quality and total execution cost, not just the price of an individual inference request. Token metrics in OpenTelemetry The current GenAI token metric conventions include proposed counters such as: - gen_ai.client.inference.usage.input_tokens - gen_ai.client.inference.usage.output_tokens - gen_ai.client.inference.usage.cache_read.input_tokens - gen_ai.client.inference.usage.reasoning.output_tokens These conventions are still in Development. There is also an important distinction between token usage attributes on individual spans and cumulative token usage metrics. A span attribute describes an individual operation. A counter or histogram is used to analyze consumption across many operations. For production cost reporting, maintain an application-level pricing registry with model and provider versions, effective dates, and the relevant unit prices. This makes historical cost calculations more reliable when provider pricing changes. References: GenAI Token Metrics · GenAI Metrics 9. Observability Is Not Evaluation This distinction is worth emphasizing. Observability tells us what happened during execution. Evaluation tells us whether the result was good enough. A trace can show that an agent: - Called the correct model. - Used three tools. - Retrieved five documents. - Completed within four seconds. - Returned a response without an exception. But none of these facts proves that the answer was correct. Consider a RAG application. The retrieval operation may complete successfully, and the model may return a fluent answer. However, the retrieved documents may be irrelevant or the final answer may contain unsupported information. From an operational perspective, the request succeeded. From a quality perspective, it failed. We need both observability and evaluation. Offline Evaluation Offline evaluation measures an AI application against a predefined dataset. For example, we can create 100 representative questions and expected outcomes. Whenever we modify a prompt, model, retrieval strategy, or agent workflow, we run the same dataset again. This helps identify regressions before deploying changes. Useful evaluation dimensions include: - Answer correctness - Relevance - Groundedness - Tool selection - Expected task completion - Policy compliance Online Evaluation Online evaluation measures actual production interactions. We can select a sample of production traces and evaluate them using: - Rule-based checks - Code-based evaluators - LLM-as-a-Judge - Human feedback The important part is to turn real production failures into future test cases. For example: 1. A production trace shows that an agent selected the wrong tool. 2. We identify the relevant input and expected behavior. 3. We create a regression dataset entry. 4. We update the prompt or agent implementation. 5. We rerun offline evaluations. 6. We deploy and monitor the next set of production traces. This creates a continuous improvement loop. Production Traces | v Failure Analysis | v Evaluation Dataset | v Offline Evaluation | v Prompt / Model / Agent Changes | v Deployment | v Online Evaluation | +------> New Regression Cases Tools worth evaluating Two examples of AI-focused observability and evaluation platforms are: Langfuse Provides tracing, evaluations, datasets, experiments, and online evaluation of production traffic. It can help connect execution traces with quality measurements. Documentation: langfuse.com Arize Phoenix An open-source observability and evaluation platform built around OpenTelemetry-based instrumentation and OpenInference conventions. It provides tracing, evaluation, datasets, experiments, and debugging capabilities. Documentation: phoenix.arize.com These tools complement OpenTelemetry. They do not replace the underlying need for correct instrumentation or a well-defined evaluation strategy. Reference: Langfuse Evaluation Concepts · Arize Phoenix 10. The Role of OpenTelemetry Collector In a production architecture, applications should not necessarily export telemetry directly to every observability backend. This is where the OpenTelemetry Collector becomes useful. The Collector receives telemetry from instrumented applications, processes it, and exports it to one or more destinations. It provides a central place for: - Batching telemetry - Filtering unwanted data - Applying processors - Handling authentication - Reducing telemetry volume - Sampling traces - Routing signals to different backends A simplified architecture looks like this: AI Applications | +----------+----------+ | | | v v v Next.js .NET API Python Agent | | | +----------+----------+ | OTLP | v OpenTelemetry Collector | +--------+--------+ | | | v v v Traces Metrics Logs | | | v v v Jaeger Prometheus Log Backend | v Grafana The same telemetry can also be routed to AI-specific observability platforms where supported. Why centralize collection? In enterprise environments, we may have several applications and teams using different frameworks and languages. A Collector provides a common ingestion point and makes it possible to apply centralized policies. For example, a Collector can filter sensitive attributes before telemetry reaches the final backend. It also allows us to change exporters or observability providers without changing the instrumentation in every application. Agent and gateway deployment OpenTelemetry supports different Collector deployment patterns. A common enterprise approach is to run lightweight Collectors close to applications and forward telemetry to centralized gateway Collectors. This provides a separation between local telemetry collection and centralized processing. However, it introduces operational complexity and additional infrastructure. The Collector itself becomes another production component that needs capacity planning, monitoring, and failure handling. Reference: OpenTelemetry Collector · Gateway Deployment Pattern 11. Sampling: How Do We Control Telemetry Volume? Agent-based workflows can generate a significant amount of telemetry. Consider an agent that performs 15 model calls and 20 tool calls during a single task. If the application handles thousands of tasks per hour, storing every span indefinitely may become expensive. Sampling helps control this volume. There are two common approaches. Head-Based Sampling The sampling decision is made when the trace starts. For example, we may decide to sample 10% of incoming requests. This is relatively simple and reduces the amount of telemetry generated or exported. However, we do not yet know whether a trace will eventually fail or become unusually slow. Tail-Based Sampling The sampling decision is made after considering the trace's collected spans. This makes it possible to retain: - All failed traces. - All traces exceeding a latency threshold. - Traces containing specific tool failures. - A percentage of successful traces. For AI agents, tail-based sampling can be particularly useful because many execution problems only become visible after several operations have completed. However, tail sampling has an important infrastructure requirement: all spans belonging to the same trace must reach the same tail-sampling Collector instance. This generally requires trace-ID-aware routing when using multiple Collector instances. A practical approach is to combine sampling strategies: - Preserve error and high-latency traces. - Retain a representative sample of successful traces. - Maintain complete aggregate metrics where possible. - Apply stricter retention policies to verbose telemetry. Reference: OpenTelemetry Sampling · Tail Sampling Processor 12. Security and Privacy Considerations This is one of the most important aspects of AI observability in enterprise environments. Traditional telemetry usually contains operational information such as request duration, HTTP status codes, and service names. AI telemetry can contain much more sensitive information. For example: - User prompts - System instructions - Generated responses - Tool arguments - Tool results - Retrieved documents - Conversation context - Customer or business identifiers Sending all this information to an observability backend can create additional privacy and data governance risks. Do not capture prompts and responses by default A particularly important detail is that the AI SDK OpenTelemetry integration records inputs and outputs by default unless configured otherwise. We can disable this behavior: registerTelemetry( new OpenTelemetry({ recordInputs: false, recordOutputs: false, }), ); For many production applications, this is a better starting point. We can still collect useful operational telemetry: - Model identifiers - Token counts - Duration - Finish reasons - Tool execution times - Error information - Workflow identifiers without exporting the complete conversation. Apply data minimization Before exporting telemetry, ask whether each attribute is genuinely needed. Avoid sending: - Access tokens - Authorization headers - Passwords - Raw customer records - Full database query results - Unfiltered tool arguments For sensitive workflows, use approved metadata rather than full payloads. Separate operational telemetry from application data An observability backend should not automatically become another storage system for business data. The fact that a trace is useful for debugging does not mean the full underlying request and response should be retained indefinitely. Define access and retention policies Enterprise environments should define: - Who can access traces. - Which teams can view prompt and response content. - How long telemetry is retained. - How data is deleted. - Which environments are allowed to capture full content. - How telemetry exports are authenticated and encrypted. A sensible approach is to use more detailed content capture in controlled development environments and much stricter policies in production. Reference: OpenTelemetry GenAI Content Capture 13. Limitations and Trade-offs OpenTelemetry provides a strong foundation, but it is not a complete AI observability solution by itself. Instrumentation coverage varies Not every framework, provider, or agent runtime exposes the same information. Some integrations can automatically trace model calls and tool execution, while others require custom instrumentation. We should verify what is actually captured rather than assuming that installing an OpenTelemetry package provides complete visibility. GenAI semantic conventions are evolving The GenAI conventions are still under development. Attribute names, operation models, and implementation support may evolve. Teams should pin versions, review changes, and avoid coupling application business logic to conventions that have not reached the required maturity. Observability does not guarantee answer quality A trace can explain what happened but does not prove that the model's result is correct. Evaluation datasets, deterministic checks, and human feedback remain necessary. Telemetry has its own cost Collecting every input, output, tool argument, and execution event can generate significant storage and processing overhead. We should measure the cost of observability itself. High-cardinality dimensions can become expensive Adding unique user IDs, conversation IDs, trace IDs, or request IDs to metric labels can create an excessive number of time series. Use traces for request-level correlation and keep metric dimensions bounded. Distributed tracing requires correct context propagation A2A communication, queues, background tasks, and remote tool execution may cross process boundaries. If context is lost, we can end up with disconnected traces. AI evaluation requires careful design LLM-as-a-Judge can provide useful signals, but it can also be inconsistent or biased. A single evaluation score should not become the only definition of quality. Combine deterministic checks, representative datasets, human review, and calibrated evaluators. 14. What Can an AI Chapter Lead Contribute? I think this is where observability moves from an implementation detail to an engineering capability. When multiple teams develop AI-powered applications, each team may implement different logging, tracing, and evaluation mechanisms. Over time, this creates fragmented visibility. One team measures token usage, another measures response latency, and another stores tool-call logs without a common correlation model. As an AI Chapter Lead, I would focus on establishing a shared observability standard that can be reused across teams and applications. 1. Define a Common Telemetry Standard Establish a baseline for the telemetry every agent-based application should produce. For example: | Category | Required information | |---|---| | Application | Service name, environment, version | | Workflow | Workflow name, workflow version | | Agent | Agent name, execution status | | Model | Provider, requested model, response model | | Usage | Input/output tokens, cache usage | | Tools | Tool name, duration, execution status | | Execution | Trace ID, span ID, error information | | Business outcome | Completed, failed, canceled, escalated | The objective is to make observability consistent without forcing every team to use the same agent framework. 2. Build a Shared Instrumentation Package We can create an internal TypeScript package that wraps the common OpenTelemetry configuration. For example: @company/ai-observability | +-- OpenTelemetry initialization +-- AI SDK integration +-- Agent span utilities +-- Workflow instrumentation +-- Tool execution tracking +-- Cost attribution +-- Evaluation metadata +-- Privacy and redaction policies This package can provide standard helpers for application-level tracing and reduce duplicated implementation. For teams using .NET, Python, or Go, equivalent instrumentation conventions can be established without requiring identical SDK implementations. 3. Standardize Agent and Workflow Metrics We should define a common set of metrics that helps teams understand both technical performance and business outcomes. Examples: - Agent success rate - Workflow completion rate - Tool-call failure rate - Model latency - Cost per successful task - Average token usage - Human intervention rate - Evaluation quality scores A shared dashboard can make it easier to compare systems and identify performance regressions. 4. Establish an Internal Evaluation Framework Observability without evaluation gives us only part of the picture. We can create reusable evaluation datasets and testing patterns for common agent behaviors. For example: - Tool selection accuracy - Missing-source detection - Correct handling of incomplete input - Permission violations - Unsupported claims - Failure recovery - Task completion quality This is particularly valuable because agent behavior can change when prompts, tools, models, or orchestration logic are modified. 5. Establish Privacy and Data Governance Define what can and cannot be captured by default. The shared implementation should make safe defaults easy to use and prevent teams from accidentally exporting sensitive prompts, responses, or tool payloads. This should include clear ownership, access policies, retention, and audit requirements. 6. Run a Cross-Team Pilot A useful pilot would be a multi-agent workflow that involves several independently deployed services. For example, a merge request review involving coordinator, security, and testing agents. The pilot should demonstrate: 1. One trace across the complete request. 2. Parent-child relationships between agents. 3. Model and tool execution spans. 4. Token and cost attribution. 5. Error and retry visibility. 6. Evaluation results associated with the completed workflow. This would provide a reference architecture that other teams can reuse. 7. Make Observability Part of the Development Lifecycle Observability should not begin after production deployment. We can introduce telemetry and evaluation requirements into the development process itself. For example: - New agents must have execution tracing. - New tools must expose execution status and duration. - Prompt changes must pass relevant regression evaluations. - New workflows must define success and failure criteria. - Production deployments must have basic operational dashboards. This makes observability a standard engineering practice rather than a separate monitoring task. 15. A Practical Adoption Roadmap I would avoid introducing every observability component at once. A phased approach is more useful. | Phase | Focus | Expected result | |---|---|---| | 1 | OpenTelemetry initialization | Basic traces and metrics | | 2 | AI SDK instrumentation | Model and tool visibility | | 3 | Custom agent spans | Complete workflow tracing | | 4 | Cost attribution | Usage and cost per task | | 5 | Evaluation | Offline and online quality checks | | 6 | Security and governance | Privacy and access controls | | 7 | Shared dashboards | Cross-team operational visibility | The first milestone should be simple: For every important agent workflow, we should be able to answer what happened, how long it took, how much it cost, and whether it achieved the intended result. Once this foundation is established, more advanced capabilities such as anomaly detection, adaptive sampling, automated evaluation, and cost-aware model routing become much easier to introduce. Conclusion AI agents introduce a new level of complexity to application observability. A single user request can trigger multiple model calls, tool executions, retrieval operations, and remote agent interactions. Monitoring only the HTTP request or final model response is not enough to understand the complete execution. OpenTelemetry provides a vendor-neutral foundation for collecting traces, metrics, and logs across these components. Combined with GenAI semantic conventions, AI SDK instrumentation, distributed tracing, and dedicated evaluation systems, it gives engineering teams a much better understanding of how agent-based applications behave in production. But the most important distinction remains: Observability tells us what happened. Evaluation tells us whether it was good. Cost attribution tells us whether it was worth it. For an AI Chapter Lead, the opportunity is to make these capabilities part of the engineering standard: shared instrumentation, consistent metrics, measurable quality, and secure telemetry practices. The goal should not be to collect more telemetry. It should be to make every production agent workflow understandable, measurable, and continuously improvable. --- References and Further Reading OpenTelemetry 1. OpenTelemetry Official Documentation — Core concepts, signals, instrumentation, and architecture. 2. OpenTelemetry JavaScript — TypeScript and Node.js instrumentation. 3. OpenTelemetry Tracing — Traces, spans, and distributed execution. 4. OpenTelemetry Context Propagation — Distributed trace context. 5. OpenTelemetry Collector — Receiving, processing, and exporting telemetry. 6. OpenTelemetry Gateway Deployment — Centralized telemetry collection. 7. OpenTelemetry Sampling — Head-based and tail-based sampling. GenAI Semantic Conventions 8. GenAI Semantic Conventions — Spans — Model operations, retrieval, and tool execution. 9. GenAI Agent Spans — Agent invocation, workflows, and tool spans. 10. GenAI Metrics — Agent duration, tool calls, and workflow metrics. 11. GenAI Token Metrics — Token consumption and usage measurements. Vercel AI SDK 12. AI SDK Telemetry — OpenTelemetry integration, span hierarchy, and custom attributes. 13. AI SDK v7 Migration Guide — Version-specific telemetry changes. 14. Next.js OpenTelemetry — Application-level instrumentation. AI Evaluation and Observability Platforms 15. Langfuse Evaluation — Online and offline evaluation. 16. Langfuse Core Concepts — Datasets, experiments, and evaluators. 17. Arize Phoenix — Open-source AI observability and evaluation. 18. OpenInference — OpenTelemetry-based instrumentation conventions for AI applications.
Introducing RhemeCore: Building the Next Generation of Open-Source System Utilities and Local AI Workflows Hello everyone! 👋 Today, we are thrilled to officially introduce RhemeCore—an independent open-source development collective dedicated to building high-performance desktop tools, efficient optimization utilities, and lightweight local AI integrations. 🚀 The Vision Behind RhemeCore Modern software ecosystems often suffer from heavy overhead, complex configurations, and bloated interfaces. As a development team, our goal with RhemeCore is to strip away the noise and build streamlined, high-efficiency tools that give power users absolute control over their systems and local workflows. RhemeCore is driven by a dedicated core team: - Emir Aras Koç (rheme18) — Founder & Lead Developer - Alex — Frontend Developer - Xiarax — Systems Engineer - Mikail Erdem Özdemir (FordloParadise) — Core Contributor --- 🛠️ Core Projects in the Ecosystem We are actively maintaining and expanding several foundational projects under the RhemeCore GitHub organization: 1. RhemeSetup: A desktop optimization and deployment utility designed to streamline software installation, system tweaking, and performance enhancement. 2. Rheme WebUI: A lightweight, responsive web interface built to seamlessly interact with local services, APIs, and AI pipelines with minimal overhead. --- 🌐 Connect With Us & Join the Journey We believe in the power of open-source collaboration. Whether you want to contribute, review our code, or follow our development updates, you can find us across our official channels: - GitHub Organization: RhemeCore on GitHub - Lead Developer: Emir Aras Koç (@rheme18 Thank you for checking out our journey. More updates, repository releases, and technical deep-dives are on the way! ⚡
CodeGraph, rewritten in Rust. v0.1.0 is out. A code graph your AI coding agent can query. One binary, no Node, no database, no API keys. vs. the original on 12 repos: 6.6x faster indexing, 13x faster cold queries, 55–88% less memory. NianJiuZst/CodeGraph-Rust t.co
@WebDesignMuseum Absolut Mozilla, with - > matthewmx86/RetroThemesFirefox t.co
Ollama: run large language models locally with one command. ollama/ollama
A 1-Wire master where the CPU never touches the bus: 8 STM32 families, zero ISRs, and a test rig that notices when the timing breaks A year ago I posted a bare-metal DS18B20 driver in r/stm32. In September I posted the three-family version of what had become a small library. 3.0 is out: a5021/stm32-async-1wire. The idea. Every 1-Wire edge is produced by TIM1, not by code. The timer runs in one-pulse mode with the repetition counter set to the number of slots, so a whole segment — a reset, 16 slots, a byte, a 750 ms conversion wait — is one hardware event. One DMA channel feeds CCR3 with the compare values for the slots; a second drains the CCR4 captures. The CPU starts an operation, polls UIF later, and is never part of the timing loop. The pin also changes electrical mode inside the transaction: actively driven low, then released for input at a hardware-defined moment. No ISR, no delay loop, no bit-banging. What changed since September. Five more families — F3, F4, G4, H5 and H7 (240 MHz, with an opt-in 480/240 core/timer split) — so eight families and eleven parts now share one MCU-independent core. A second slave driver: DS2431 1-Kbit EEPROM, with scratchpad write, read-back verification and the t_PROG hold-off. And a real application instead of another demo: 9_multi runs seven DS18B20s and one DS2431 on the same wire as a peak/low temperature logger, writing self-validating CRC records to EEPROM — ROM blocks before the records that reference them, so a power cut cannot leave a record pointing at a ROM that is not there. The two drivers take turns owning the bus. 9_multi: DS2431 Write Scratchpad 0x0F — command, address and the sensor's 8-byte ROM, decoded from a real 8 MHz capture. Every edge is generated by TIM1 + DMA. The part I actually care about. Hardware-timed code fails silently, so most of the work went into making failures loud. 300+ host tests per family run the driver against a behavioral model of TIM1/DMA; 14 libFuzzer harnesses cover the state machines; a mutation run injects 74 deliberate defects into the port and requires the suite to catch all 74. On the bench a logic analyzer checks the wire itself — slot widths and the duration of the long conversion wait. Some bugs only that layer found: an F3 DMA channel mapping that was one channel off, which just makes the bus look dead; the H5 GPDMA counting source bytes where the classic DMA counts transfers; and presence detection that used to encode "no device" as a zero in the capture buffer — indistinguishable from a real 0 µs edge. Presence is now proved by the captured edge count. If you want to look at traffic without hardware, there is an offline browser decoder for sigrok captures: a5021.github.io — resets, Search ROM triplets, Match/Skip ROM, scratchpad and DS2431 chains, no upload, works from file://. Limits, plainly. The bus is PA10 and the timer must be an advanced-control one with RCR, BDTR and OPM, which rules out parts like L0. One driver owns the bus at a time, no deinit, GCC only. L4 and C0 are next: the port is small if the CH2/CH4 DMA requests coexist on one timer, and does not exist if they do not. That is the experiment.
Trimming Container Bloat with Docker History and Dive > Why this matters: Large container images increase pull times during CI/CD, consume unnecessary storage in container registries, and expand the attack surface by including extraneous binary dependencies. Managing image size is a fundamental practice for maintaining lean, reproducible data pipelines that scale predictably across environments. A Docker image is not a single file; it is a stack of filesystem changes. A common misconception is that deleting a file in a later RUN command removes it from the final image. It does not. The file persists in the layer where it was created, and subsequent layers simply mark it as "hidden" or "deleted," meaning your image size remains bloated by the original data. If you are shipping data processing agents or heavy analytics environments, you are likely carrying "ghost" data—temporary caches, source code, or build artifacts—that provide no runtime value. Finding these hidden bytes requires more than just docker images. You need to peel back the layers. Prerequisites To follow this tutorial, you need the following installed: - Docker Engine (version 20.10 or higher). - Dive (a tool for exploring a docker image, layer by layer). See the official repository for installation instructions. - A terminal environment with permissions to build images. !Calculator, magnifying glass, and chart with gears on paper Photo by Sasun Bughdaryan on Unsplash Step 1: Inspecting layers with docker history Before using specialized tools, understand what Docker reports natively. The docker history command displays the commands used to create each layer and the resulting size of that layer. Create a dummy Dockerfile to visualize the problem: FROM python:3.11-slim RUN apt-get update && apt-get install -y gcc g++ COPY ./data_processing_script.py /app/script.py RUN pip install pandas==2.2.0 RUN rm -rf /root/.cache/pip Build the image: docker build -t bloat-test:latest . Now, run the history command: docker history --no-trunc bloat-test:latest The output shows every instruction. Look for layers with large sizes. You will notice that the apt-get install layer is significant. Even though you might think you are cleaning up in a later layer, the initial download and extraction remain permanently in the image history. Step 2: Using Dive to visualize the bloat docker history is text-based and difficult to parse for large images. Dive provides an interactive TUI (Text User Interface) that allows you to navigate each layer and see exactly which files were added, modified, or removed. Run Dive on your image: dive bloat-test:latest Navigate the interface using the arrow keys: 1. Left Panel: Lists the Docker layers. 2. Right Panel: Shows the contents of the filesystem for the selected layer. Watch for the "Image Efficiency Score" in the top right. If you see a low score, it usually indicates that you are creating files in one layer and deleting them in another. Dive highlights these changes in red or green. If a file appears in a layer and is later deleted, it is still consuming space in your final build. Step 3: Implementing multi-stage builds The most effective way to eliminate bloat is by using multi-stage builds. This approach ensures that build-time dependencies (like compilers or header files) never make it into the final runtime image. Modify your Dockerfile to use a build stage: # Stage 1: Build dependencies FROM python:3.11-slim AS builder RUN apt-get update && apt-get install -y gcc g++ COPY requirements.txt . RUN pip install --user -r requirements.txt # Stage 2: Runtime image FROM python:3.11-slim WORKDIR /app # Copy only the installed packages from the builder COPY --from=builder /root/.local /root/.local COPY . . ENV PATH=/root/.local/bin:$PATH CMD ["python", "script.py"] Build the new image: docker build -t lean-image:latest . Run dive again on lean-image:latest. You will observe a significant reduction in the "Efficiency Score" and total size, as the gcc and g++ compilers were discarded at the end of the builder stage. Step 4: Minimizing layers with build techniques Every RUN command in a Dockerfile creates a new layer. You can reduce the number of layers by chaining commands. This is particularly useful for package management. Instead of: RUN apt-get update RUN apt-get install -y git RUN apt-get clean Use: RUN apt-get update && \ apt-get install -y git && \ apt-get clean && \ rm -rf /var/lib/apt/lists/* Combining these into a single RUN instruction ensures that the temporary files created by apt-get are removed within the same layer, preventing them from being committed to the final image. !a close-up of a circuit board Photo by Anne Nygård on Unsplash Common pitfalls - The .dockerignore oversight: If you don't use a .dockerignore file, you are likely copying local .git directories, virtual environments, or __pycache__ folders into your image. Always add these to a .dockerignore file in your root directory to keep the build context clean. - Over-reliance on apt-get clean: While cleaning package lists is good practice, it is secondary to avoiding the installation of unnecessary tools entirely. Always prefer distroless or alpine base images if your application dependencies allow it. - Ignoring cache mounts: If you are using BuildKit (enabled by default in modern Docker), use --mount=type=cache for your package manager (e.g., pip or apt). This caches files during the build but does not include them in the resulting image layer, significantly speeding up subsequent builds without bloating the output. Conclusion Bloated containers are a silent tax on your data engineering velocity. By inspecting layers with dive and enforcing multi-stage builds, you ensure that your production artifacts contain only what is strictly necessary to execute your code. This not only speeds up deployment cycles but also improves the security posture of your infrastructure by reducing the number of binaries and libraries present in your environment. Try it: Take a current production Dockerfile that you suspect is oversized, run dive on it today, and identify the single largest layer. Then, apply a multi-stage build pattern to isolate that layer's dependencies and compare the final image size. Cover photo by Rinson Chory on Unsplash. --- This article was drafted with AI assistance and is intended for technical review and fact-checking before publication.
@Bady_Ohh @max45994648 @AcervoAPKdois RouBR-dev/PortHub tentem pelo Porthub, baixei o meu lá, só mudem o método de download para Externo caso os arquivos não sejam instalados t.co
Free Local AI Voice: What is VoiceStudio? (Guide) VoiceStudio is free, open source, and runs on your own machine — past 98,000 GitHub stars. Clone voices, design voices, dub videos, dictate, transcribe, and narrate audiobooks in 600+ languages, with no account and no cloud. The narration in this video was rendered locally by the same app. What you hear is what you get. What this covers: the local-render hook and the setup-versus-effort tradeoff, the 98K-star story, a full tour of all six workflows, the 19-engine catalog, one-line install on Mac, Windows, Linux, and Docker, live release and star-count verification, the license honesty most videos skip, the real limits including the tinkerer tax, and how to wire it into your homelab with the local API and MCP server. Prefer zero setup and the best possible voice quality instead? That lane is ElevenLabs. Chapters: 0:00 Rendered on my machine 0:40 VoiceStudio: 98,000 stars, fully local 1:12 This voice is the app 1:36 Clone, design, dub 2:10 19 speech engines, 10 transcription 2:51 One line, every platform 3:28 Live proof: release, stars, voices 3:55 Free app, check the weights 4:24 Honest limits 5:06 Wire it into your homelab 5:36 Verdict: two lanes, your call Sources: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest Links: s-scottek.com Credits: all screenshots captured by Scottek from public project pages. Star and release figures verified same-day via public APIs and pages. Voiceover: synthetic narration. Thumbnail: AI-generated hero art with Scottek brand type. #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [ar] ذكاء اصطناعي محلي ومجاني للصوت: ما هو VoiceStudio؟ (دليل) VoiceStudio برنامج مجاني ومفتوح المصدر، ويعمل على جهازك الشخصي - حائز على أكثر من 98,000 نجمة على GitHub. يمكنك استنساخ الأصوات، وتصميمها، ودبلجة الفيديوهات، وإملاء النصوص، وكتابة النصوص الصوتية، وسرد الكتب الصوتية بأكثر من 600 لغة، دون الحاجة إلى حساب أو خدمة سحابية. تم إنتاج التعليق الصوتي في هذا الفيديو محليًا باستخدام نفس التطبيق. ما تسمعه هو ما تحصل عليه. يتناول هذا الفيديو: آلية الإنتاج المحلي، وموازنة الإعداد والجهد المبذول، وقصة حصوله على 98 ألف نجمة، وجولة شاملة في جميع مسارات العمل الستة، وقائمة محركات الصوت التسعة عشر، والتثبيت بسطر واحد على أنظمة Mac وWindows وLinux وDocker، والإصدارات المباشرة والتحقق من عدد النجوم، وشفافية الترخيص التي تتجاهلها معظم الفيديوهات، والحدود الحقيقية بما في ذلك تكلفة التعديل، وكيفية ربطه بمختبرك المنزلي باستخدام واجهة برمجة التطبيقات المحلية وخادم MCP. هل تفضل عدم وجود أي إعداد وأفضل جودة صوت ممكنة؟ إليك الحل: ElevenLabs. الفصول: 0:00 تم المعالجة على جهازي 0:40 VoiceStudio: 98,000 نجمة، محلي بالكامل 1:12 هذا الصوت هو التطبيق 1:36 الاستنساخ، التصميم، الدبلجة 2:10 19 محركًا للكلام، 10 نسخ صوتية 2:51 سطر واحد، على جميع المنصات 3:28 دليل عملي: الإصدار، النجوم، الأصوات 3:55 تطبيق مجاني، تحقق من الأوزان 4:24 حدود حقيقية 5:06 قم بتوصيله بمختبرك المنزلي 5:36 الخلاصة: خياران، القرار لك المصادر: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest الروابط: s-scottek.com حقوق النشر: جميع لقطات الشاشة مأخوذة بواسطة Scottek من صفحات المشروع العامة. تم التحقق من أرقام النجوم والإصدار في نفس اليوم عبر واجهات برمجة التطبيقات والصفحات العامة. التعليق الصوتي: سرد اصطناعي. الصورة المصغرة: صورة رئيسية مُولّدة بالذكاء الاصطناعي بشعار سكوتيك. #مختبر_منزلي #استضافة_ذاتية #ذكاء_اصطناعي_محلي #مفتوح_المصدر #استوديو_صوتي #تحويل_نص_إلى_نص #ذكاء_اصطناعي_صوتي #لينكس #دوكر #ذكاء_اصطناعي [bn] ফ্রি লোকাল এআই ভয়েস: ভয়েস স্টুডিও (VoiceStudio) কী? (গাইড) VoiceStudio বিনামূল্যে, ওপেন সোর্স এবং আপনার নিজের মেশিনে চলে — গিটহাবে এর স্টার সংখ্যা ৯৮,০০০ ছাড়িয়ে গেছে। কোনো অ্যাকাউন্ট বা ক্লাউড ছাড়াই ৬০০-এর বেশি ভাষায় ভয়েস ক্লোন করুন, ভয়েস ডিজাইন করুন, ভিডিও ডাব করুন, ডিক্টেট করুন, ট্রান্সক্রাইব করুন এবং অডিওবুক ন্যারেট করুন। এই ভিডিওর ন্যারেটিভটি একই অ্যাপ দিয়ে স্থানীয়ভাবে রেন্ডার করা হয়েছে। আপনি যা শুনছেন, ঠিক তাই পাচ্ছেন। এখানে যা যা থাকছে: লোকাল-রেন্ডার হুক এবং সেটআপ বনাম পরিশ্রমের সুবিধা-অসুবিধা, ৯৮ হাজার স্টারের গল্প, ছয়টি ওয়ার্কফ্লোর সম্পূর্ণ বিবরণ, ১৯টি ইঞ্জিনের ক্যাটালগ, Mac, Windows, Linux, এবং Docker-এ এক লাইনে ইনস্টল করার সুবিধা, লাইভ রিলিজ এবং স্টার সংখ্যা যাচাই, লাইসেন্সের সততা যা বেশিরভাগ ভিডিওতে এড়িয়ে যাওয়া হয়, খুঁটিনাটি নিয়ে ঘাঁটাঘাঁটি করার বাড়তি খরচসহ এর আসল সীমাবদ্ধতা, এবং লোকাল API ও MCP সার্ভারের মাধ্যমে কীভাবে এটিকে আপনার হোমল্যাবের সাথে যুক্ত করবেন। এর পরিবর্তে কি কোনো সেটআপ ছাড়াই সেরা ভয়েস কোয়ালিটি চান? সেই বিকল্পটি হলো ElevenLabs। অধ্যায়সমূহ: ০:০০ আমার মেশিনে রেন্ডার করা হয়েছে ০:৪০ ভয়েসস্টুডিও: ৯৮,০০০ স্টার, সম্পূর্ণ লোকাল ১:১২ এই ভয়েসটিই অ্যাপ ১:৩৬ ক্লোন, ডিজাইন, ডাব ২:১০ ১৯টি স্পিচ ইঞ্জিন, ১০টি ট্রান্সক্রিপশন ২:৫১ এক লাইন, প্রতিটি প্ল্যাটফর্ম ৩:২৮ সরাসরি প্রমাণ: রিলিজ, স্টার, ভয়েস ৩:৫৫ ফ্রি অ্যাপ, ওয়েটগুলো পরীক্ষা করুন ৪:২৪ সৎ সীমাবদ্ধতা ৫:০৬ আপনার হোমল্যাবে এটি সংযুক্ত করুন ৫:৩৬ রায়: দুটি লেন, সিদ্ধান্ত আপনার উৎস: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest লিঙ্ক: s-scottek.com কৃতিত্ব: সমস্ত স্ক্রিনশট স্কটেক কর্তৃক পাবলিক প্রজেক্ট পেজ থেকে নেওয়া হয়েছে। স্টার এবং রিলিজের পরিসংখ্যান একই দিনে পাবলিক এপিআই এবং পেজের মাধ্যমে যাচাই করা হয়েছে। ভয়েসওভার: কৃত্রিম বর্ণনা। থাম্বনেইল: স্কটেক ব্র্যান্ড টাইপ সহ এআই-নির্মিত হিরো আর্ট। #হোমল্যাব #সেলফহোস্টেড #লোকালএআই #ওপেনসোর্স #ভয়েসস্টুডিও #টিটিএস #ভয়েসএআই #লিনাক্স #ডকার #এআই [de-DE] Kostenlose lokale KI-Stimme: Was ist VoiceStudio? (Anleitung) VoiceStudio ist kostenlos, Open Source und läuft auf Ihrem eigenen Rechner – und hat bereits über 98.000 GitHub-Sterne. Klonen Sie Stimmen, erstellen Sie eigene Stimmen, synchronisieren Sie Videos, diktieren Sie, transkribieren Sie und vertonen Sie Hörbücher in über 600 Sprachen – ganz ohne Konto und Cloud. Die Sprachaufnahme in diesem Video wurde lokal mit derselben App gerendert. Sie erhalten genau das, was Sie hören. In diesem Video geht es um: die lokale Rendering-Funktion und den Aufwand im Verhältnis zur Einrichtung, die Erfolgsgeschichte mit 98.000 Sternen, eine vollständige Übersicht aller sechs Workflows, den Katalog mit 19 Sprach-Engines, die Installation mit nur einer Zeile Code unter Mac, Windows, Linux und Docker, die Live-Veröffentlichung und die Überprüfung der Sterneanzahl, die Lizenzbedingungen, die in den meisten Videos ausgelassen werden, die tatsächlichen Grenzen inklusive der Kosten für individuelle Anpassungen sowie die Integration in Ihr Heimnetzwerk mit der lokalen API und dem MCP-Server. Bevorzugen Sie hingegen eine Einrichtung ohne Aufwand und die bestmögliche Sprachqualität? Dann ist ElevenLabs die richtige Wahl. Kapitel: 0:00 Auf meinem Rechner gerendert 0:40 VoiceStudio: 98.000 Sterne, vollständig lokal 1:12 Diese Stimme ist die App 1:36 Klonen, Designen, Synchronisieren 2:10 19 Sprachausgabe-Engines, 10 Transkription 2:51 Eine Zeile, jede Plattform 3:28 Live-Beweis: Veröffentlichung, Sterne, Stimmen 3:55 Kostenlose App, Gewichtungen prüfen 4:24 Ehrliche Grenzen 5:06 Integration in Ihr Heimnetzwerk 5:36 Fazit: Zwei Spuren, Sie entscheiden Quellen: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest Links: s-scottek.com Credits: Alle Screenshots wurden von Scottek von öffentlichen Projektseiten aufgenommen. Sterne- und Veröffentlichungszahlen wurden am selben Tag über öffentliche APIs und Seiten verifiziert. Voiceover: Synthetische Erzählung. Vorschaubild: KI-generiertes Hero-Artwork mit Scottek-Logo. #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [es-US] Voz IA local y gratuita: ¿Qué es Voice Studio? (Guía) VoiceStudio es gratuito, de código abierto y se ejecuta en tu propio ordenador, con más de 98 000 estrellas en GitHub. Clona voces, diseña voces, dobla vídeos, dicta, transcribe y narra audiolibros en más de 600 idiomas, sin necesidad de cuenta ni nube. La narración de este vídeo se renderizó localmente con la misma aplicación. Lo que oyes es lo que obtienes. Este vídeo incluye: el gancho de renderizado local y la relación entre configuración y esfuerzo, la historia de las 98 000 estrellas, un recorrido completo por los seis flujos de trabajo, el catálogo de 19 motores, la instalación con una sola línea en Mac, Windows, Linux y Docker, el lanzamiento en vivo y la verificación del número de estrellas, la honestidad de la licencia que la mayoría de los vídeos omiten, las limitaciones reales, incluyendo el coste adicional para los usuarios que experimentan, y cómo integrarlo en tu laboratorio doméstico con la API local y el servidor MCP. ¿Prefieres una configuración sencilla y la mejor calidad de voz posible? ElevenLabs es la solución. Capítulos: 0:00 Renderizado en mi máquina 0:40 VoiceStudio: 98.000 estrellas, totalmente local 1:12 Esta voz es la app 1:36 Clonar, diseñar, doblar 2:10 19 motores de voz, 10 de transcripción 2:51 Una línea, todas las plataformas 3:28 Prueba en vivo: lanzamiento, estrellas, voces 3:55 App gratuita, comprueba los pesos 4:24 Límites honestos 5:06 Conéctalo a tu laboratorio doméstico 5:36 Veredicto: dos carriles, tú decides Fuentes: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest Enlaces: s-scottek.com Créditos: todas las capturas de pantalla fueron tomadas por Scottek de las páginas públicas del proyecto. Las cifras de estrellas y lanzamientos se verificaron el mismo día a través de API y páginas públicas. Locución: narración sintética. Miniatura: ilustración principal generada por IA con la tipografía de la marca Scottek. #homelab #autoalojado #ialocal #códigoabierto #estudiodevoz #tts #iavoz #linux #docker #ia [fr-FR] Voix IA locale gratuite : Qu'est-ce que Voice Studio ? (Guide) VoiceStudio est gratuit, open source et fonctionne sur votre propre machine — et compte plus de 98 000 étoiles sur GitHub. Clonez et créez des voix, doublez des vidéos, dictez, transcrivez et enregistrez des livres audio dans plus de 600 langues, sans compte ni cloud. La narration de cette vidéo a été rendue localement avec la même application. Le résultat est fidèle à la qualité sonore. Cette vidéo aborde : le rendu local et le compromis entre configuration et effort, l’histoire des 98 000 étoiles, une présentation complète des six flux de travail, le catalogue de 19 moteurs, l’installation en une ligne sur Mac, Windows, Linux et Docker, la publication en direct et la vérification du nombre d’étoiles, la transparence de la licence (souvent omise dans les vidéos), les limites réelles (notamment le coût pour les bidouilleurs) et comment l’intégrer à votre environnement personnel avec l’API locale et le serveur MCP. Vous préférez une solution sans configuration et une qualité vocale optimale ? Optez pour ElevenLabs. Chapitres : 0:00 Rendu sur ma machine 0:40 VoiceStudio : 98 000 étoiles, entièrement local 1:12 Cette voix est l’application 1:36 Clonage, conception, doublage 2:10 19 moteurs vocaux, 10 transcriptions 2:51 Une seule ligne, toutes plateformes 3:28 Preuve en direct : version, étoiles, voix 3:55 Application gratuite, vérifiez les poids 4:24 Limites réalistes 5:06 Intégration à votre labo perso 5:36 Verdict : deux voies, à vous de choisir Sources : debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest Liens : s-scottek.com Crédits : toutes les captures d’écran proviennent des pages publiques du projet et ont été réalisées par Scottek. Les chiffres d’étoiles et de version ont été vérifiés le jour même via les API et pages publiques. Voix off : narration de synthèse. Vignette : illustration générée par IA avec la typographie de la marque Scottek. #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [hi] मुफ़्त लोकल AI वॉइस: VoiceStudio क्या है? (गाइड) VoiceStudio मुफ़्त, ओपन सोर्स है और आपके अपने कंप्यूटर पर चलता है — GitHub पर इसे 98,000 से ज़्यादा स्टार मिल चुके हैं। बिना किसी अकाउंट या क्लाउड के 600 से ज़्यादा भाषाओं में आवाज़ क्लोन करें, आवाज़ डिज़ाइन करें, वीडियो डब करें, बोलकर रिकॉर्ड करें, ट्रांसक्राइब करें और ऑडियोबुक सुनाएँ। इस वीडियो में सुनाई गई आवाज़ भी इसी ऐप से लोकल रूप से रेंडर की गई है। जो आप सुनते हैं, वही आपको मिलता है। इसमें शामिल हैं: लोकल रेंडर हुक और सेटअप बनाम प्रयास का संतुलन, 98,000 स्टार की कहानी, सभी छह वर्कफ़्लो का पूरा विवरण, 19 इंजन वाला कैटलॉग, Mac, Windows, Linux और Docker पर एक लाइन में इंस्टॉल, लाइव रिलीज़ और स्टार-काउंट वेरिफिकेशन, लाइसेंस की वह सच्चाई जिसे ज़्यादातर वीडियो नज़रअंदाज़ कर देते हैं, असली सीमाएँ जिनमें टिंकरर टैक्स भी शामिल है, और लोकल API और MCP सर्वर के साथ इसे अपने होमलैब में कैसे जोड़ें। अगर आप बिना किसी सेटअप के बेहतरीन आवाज़ की क्वालिटी चाहते हैं, तो ElevenLabs आपके लिए है। अध्याय: 0:00 मेरे कंप्यूटर पर रेंडर किया गया 0:40 वॉयस स्टूडियो: 98,000 स्टार, पूरी तरह से स्थानीय 1:12 यह आवाज़ ही ऐप है 1:36 क्लोन, डिज़ाइन, डबिंग 2:10 19 स्पीच इंजन, 10 ट्रांसक्रिप्शन 2:51 एक लाइन, हर प्लेटफॉर्म 3:28 लाइव प्रमाण: रिलीज़, स्टार, आवाज़ें 3:55 मुफ़्त ऐप, वज़न जांचें 4:24 ईमानदार सीमाएं 5:06 इसे अपने होमलैब से कनेक्ट करें 5:36 निष्कर्ष: दो लेन, आपका निर्णय स्रोत: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest लिंक: s-scottek.com क्रेडिट: सभी स्क्रीनशॉट स्कॉटेक द्वारा सार्वजनिक प्रोजेक्ट पेजों से लिए गए हैं। स्टार रेटिंग और रिलीज़ के आंकड़े सार्वजनिक API और पेजों के माध्यम से उसी दिन सत्यापित किए गए। वॉइसओवर: कृत्रिम उच्चारण। थंबनेल: स्कॉटेक ब्रांड टाइप के साथ AI द्वारा निर्मित हीरो आर्ट। #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [id] Suara AI Lokal Gratis: Apa Itu Voice Studio? (Panduan) VoiceStudio gratis, open source, dan berjalan di mesin Anda sendiri — telah melampaui 98.000 bintang GitHub. Kloning suara, desain suara, sulih suara video, dikte, transkripsi, dan narasikan buku audio dalam 600+ bahasa, tanpa akun dan tanpa cloud. Narasi dalam video ini dirender secara lokal oleh aplikasi yang sama. Apa yang Anda dengar adalah apa yang Anda dapatkan. Apa yang dibahas di sini: kait rendering lokal dan pertimbangan antara pengaturan dan upaya, kisah 98 ribu bintang, tur lengkap keenam alur kerja, katalog 19 mesin, instalasi satu baris di Mac, Windows, Linux, dan Docker, rilis langsung dan verifikasi jumlah bintang, kejujuran lisensi yang dilewati sebagian besar video, batasan sebenarnya termasuk pajak pengutak-atik, dan cara menghubungkannya ke lab rumahan Anda dengan API lokal dan server MCP. Lebih suka pengaturan nol dan kualitas suara terbaik? Jalur itu adalah ElevenLabs. Bab: 0:00 Dirender di mesin saya 0:40 VoiceStudio: 98.000 bintang, sepenuhnya lokal 1:12 Suara ini adalah aplikasinya 1:36 Kloning, desain, sulih suara 2:10 19 mesin pengucapan, 10 transkripsi 2:51 Satu baris, setiap platform 3:28 Bukti langsung: rilis, bintang, suara 3:55 Aplikasi gratis, periksa bobotnya 4:24 Batasan yang jujur 5:06 Hubungkan ke lab rumahan Anda 5:36 Putusan: dua jalur, pilihan Anda Sumber: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest Tautan: s-scottek.com Kredit: semua tangkapan layar diambil oleh Scottek dari halaman proyek publik. Angka bintang dan rilis diverifikasi pada hari yang sama melalui API dan halaman publik. Narasi suara: narasi sintetis. Gambar mini: gambar utama yang dihasilkan AI dengan jenis huruf merek Scottek. #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [it] Voce AI locale gratuita: cos'è VoiceStudio? (Guida) VoiceStudio è gratuito, open source e funziona sul tuo computer: ha già superato le 98.000 stelle su GitHub. Clona voci, progetta voci, doppia video, detta, trascrivi e narra audiolibri in oltre 600 lingue, senza bisogno di un account o del cloud. La narrazione in questo video è stata renderizzata localmente dalla stessa applicazione. Ciò che senti è ciò che ottieni. Questo video illustra: il meccanismo di rendering locale e il compromesso tra configurazione e impegno, la storia delle 98.000 stelle, una panoramica completa di tutti e sei i flussi di lavoro, il catalogo di 19 motori, l'installazione con una sola riga di codice su Mac, Windows, Linux e Docker, la versione live e la verifica del conteggio delle stelle, la trasparenza della licenza che la maggior parte dei video omette, i limiti reali, inclusa la "tassa per gli smanettoni", e come integrarlo nel tuo homelab con l'API locale e il server MCP. Preferisci una configurazione zero e la migliore qualità vocale possibile? Per questo c'è ElevenLabs. Capitoli: 0:00 Rendering effettuato sulla mia macchina 0:40 VoiceStudio: 98.000 stelle, completamente locale 1:12 Questa voce è l'app 1:36 Clona, progetta, doppia 2:10 19 motori vocali, 10 trascrizioni 2:51 Una sola riga, ogni piattaforma 3:28 Prova dal vivo: rilascio, stelle, voci 3:55 App gratuita, controlla i pesi 4:24 Limiti onesti 5:06 Collegalo al tuo homelab 5:36 Verdetto: due corsie, a te la scelta Fonti: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest Link: s-scottek.com Crediti: tutti gli screenshot sono stati acquisiti da Scottek dalle pagine pubbliche del progetto. I dati relativi a stelle e rilasci sono stati verificati lo stesso giorno tramite API e pagine pubbliche. Voce fuori campo: narrazione sintetica. Miniatura: grafica principale generata dall'IA con il marchio Scottek. #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [iw] קול AI מקומי בחינם: מה זה VoiceStudio? (מדריך) VoiceStudio היא תוכנה חינמית, קוד פתוח, ופועלת על המחשב שלכם - מעבר ל-98,000 כוכבים של GitHub. שכפלו קולות, עצבו קולות, דיבבו סרטונים, הכתבו, תמללו וקראו ספרי שמע ביותר מ-600 שפות, ללא חשבון וללא ענן. הקריינות בסרטון זה עובדה באופן מקומי על ידי אותה אפליקציה. מה שאתם שומעים זה מה שאתם מקבלים. מה זה מכסה: ה-hook של הרינדור המקומי והפשרה בין הגדרה למאמץ, סיפור 98,000 כוכבים, סיור מלא בכל ששת זרימות העבודה, קטלוג 19 מנועי עיבוד, התקנה בשורה אחת ב-Mac, Windows, Linux ו-Docker, שחרור חי ואימות ספירת כוכבים, כנות הרישיון שרוב הסרטונים מדלגים עליה, המגבלות האמיתיות כולל מס הפיתוח, וכיצד לחבר אותו למעבדה הביתית שלכם עם ה-API המקומי ושרת ה-MCP. מעדיפים אפס הגדרה ואת איכות הקול הטובה ביותר? הנתיב הזה הוא ElevenLabs. פרקים: 0:00 עיבוד במחשב שלי 0:40 VoiceStudio: 98,000 כוכבים, מקומי לחלוטין 1:12 הקול הזה הוא האפליקציה 1:36 שכפול, עיצוב, דיבוב 2:10 19 מנועי דיבור, 10 תמלול 2:51 שורה אחת, כל פלטפורמה 3:28 הוכחה חיה: שחרור, כוכבים, קולות 3:55 אפליקציה חינמית, בדיקת המשקלים 4:24 מגבלות כנות 5:06 חיבור למעבדה הביתית שלך 5:36 פסק דין: שני נתיבים, ההחלטה שלך מקורות: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest קישורים: s-scottek.com קרדיטים: כל צילומי המסך שצולמו על ידי Scottek מדפי הפרויקט הציבוריים. נתוני כוכבים ושחרור אומתו באותו היום דרך ממשקי API ודפים ציבוריים. קריינות: קריינות סינתטית. תמונה ממוזערת: גרפיקה של גיבור שנוצרה על ידי בינה מלאכותית עם סוג מותג של Scottek. #homelab #selfhosting #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [ja] 完全無料のローカルAI音声:VoiceStudioとは?(導入ガイド) VoiceStudioは無料のオープンソースソフトウェアで、98,000以上のGitHubスターを獲得し、ご自身のマシンで動作します。アカウントもクラウドも不要で、600以上の言語で音声の複製、音声デザイン、動画の吹き替え、音声入力、文字起こし、オーディオブックのナレーションが可能です。 この動画のナレーションは、同じアプリでローカルにレンダリングされています。聞こえてくる音声がそのまま出力されます。 この動画の内容:ローカルレンダリングの仕組みとセットアップの手間、98,000スター獲得の経緯、6つのワークフローの完全ガイド、19種類のエンジンカタログ、Mac、Windows、Linux、Dockerへのワンラインインストール、ライブリリースとスター数の検証、多くの動画で省略されているライセンスに関する説明、カスタマイズによる制限事項、ローカルAPIとMCPサーバーを使ったホームラボへの接続方法。セットアップ不要で最高の音声品質を求めるなら、ElevenLabsがおすすめです。 チャプター: 0:00 マシンでレンダリング 0:40 VoiceStudio:98,000スター、完全ローカル 1:12 この音声こそがアプリ 1:36 クローン、デザイン、吹き替え 2:10 19種類の音声エンジン、10種類の文字起こし機能 2:51 ワンライン、あらゆるプラットフォームに対応 3:28 ライブパフォーマンス:リリース、スター、音声 3:55 無料アプリ、評価を確認 4:24 正直な制限事項 5:06 ホームラボに接続 5:36 結論:2つの選択肢、あなたの判断 情報源: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest リンク: s-scottek.com クレジット:すべてのスクリーンショットは、Scottekが公開プロジェクトページからキャプチャしたものです。スター数とリリース数は、公開APIとページを通じて同日中に検証済みです。ナレーション:合成音声。サムネイル:Scottekブランドフォントを使用したAI生成ヒーローアート。 #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [ko] 무료 로컬 AI 음성: Voice Studio란 무엇인가? (가이드) VoiceStudio는 무료 오픈 소스 소프트웨어로, 98,000개 이상의 GitHub 스타를 획득하며 로컬 컴퓨터에서 바로 실행할 수 있습니다. 계정이나 클라우드 서비스 없이 600개 이상의 언어로 음성 복제, 음성 디자인, 비디오 더빙, 음성 인식, 텍스트 변환, 오디오북 내레이션을 할 수 있습니다. 이 영상의 내레이션은 VoiceStudio 앱을 사용하여 로컬에서 렌더링되었습니다. 들리는 그대로 출력됩니다. 이 영상에서는 로컬 렌더링 기능과 설정 대비 노력의 균형, 98,000개 스타 획득 비결, 6가지 워크플로우 전체 소개, 19가지 엔진 카탈로그, Mac, Windows, Linux 및 Docker에서의 간편한 설치, 라이브 릴리스 및 스타 수 검증, 대부분의 영상에서 생략되는 라이선스 정보, 실제 사용 제한 사항(사용자 편의성을 고려한), 로컬 API 및 MCP 서버를 사용하여 홈랩에 VoiceStudio를 연결하는 방법 등을 다룹니다. 설정이 전혀 필요 없고 최고의 음질을 원하신다면 ElevenLabs를 추천합니다. 이 영상에서는 로컬 렌더링 기능과 설정 대비 노력의 균형, 98,000개 스타 획득 비결, 6가지 워크플로우 전체 소개, 19가지 엔진 카탈로그, Mac, Windows, Linux 및 Docker에서의 간편한 설치, 실제 릴리스 및 스타 수 검증, 대부분의 영상에서 생략되는 라이선스 정보, 설정 관련 추가 비용 등 실제적인 한계점, 그리고 로컬 API와 MCP 서버를 사용하여 홈랩에 VoiceStudio를 연결하는 방법까지 자세히 설명합니다. 설정이 전혀 필요 없고 최고의 음질을 원하신다면 ElevenLabs를 고려해 보세요. 목차: 0:00 내 컴퓨터에서 렌더링 0:40 VoiceStudio: 98,000개의 별, 완전 로컬 개발 1:12 이 음성이 바로 앱입니다 1:36 클론, 디자인, 더빙 2:10 19개의 음성 엔진, 10개의 전사 기능 2:51 한 줄로 모든 플랫폼 지원 3:28 실제 사용 후기: 출시, 별점, 음성 3:55 무료 앱, 가중치 확인 4:24 솔직한 한계 5:06 홈랩에 연결하기 5:36 결론: 두 가지 선택지, 당신의 결정 출처: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest 링크: s-scottek.com 크레딧: 모든 스크린샷은 Scottek이 공개 프로젝트 페이지에서 캡처했습니다. 별점 및 출시 수치는 공개 API 및 페이지를 통해 당일 확인되었습니다. 내레이션: 합성 음성. 썸네일: Scottek 브랜드 서체를 사용한 AI 생성 히어로 아트. #홈랩 #자체호스팅 #로컬AI #오픈소스 #보이스스튜디오 #TTS #보이스AI #리눅스 #도커 #AI [ml] സൗജന്യ ലോക്കൽ AI വോയ്സ്: എന്താണ് VoiceStudio? (ഗൈഡ്) വോയ്സ് സ്റ്റുഡിയോ സൌജന്യവും ഓപ്പൺ സോഴ്സുമാണ്, കൂടാതെ നിങ്ങളുടെ സ്വന്തം മെഷീനിൽ പ്രവർത്തിക്കുന്നു — 98,000 GitHub സ്റ്റാറുകളിൽ അധികമുണ്ട്. അക്കൗണ്ടും ക്ലൗഡും ഇല്ലാതെ, 600+ ഭാഷകളിൽ ക്ലോൺ വോയ്സുകൾ, ഡിസൈൻ വോയ്സുകൾ, ഡബ് വീഡിയോകൾ, ഡിക്റ്റേറ്റ് ചെയ്യുക, ട്രാൻസ്ക്രൈബ് ചെയ്യുക, ആഖ്യാനം ചെയ്യുക ഓഡിയോബുക്കുകൾ. ഈ വീഡിയോയിലെ വിവരണം ഒരേ ആപ്പ് തന്നെയാണ് ലോക്കലായി റെൻഡർ ചെയ്തത്. നിങ്ങൾക്ക് ലഭിക്കുന്നത് നിങ്ങൾ കേൾക്കുന്നതാണ്. ഇതിൽ ഉൾപ്പെടുന്നത്: ലോക്കൽ-റെൻഡർ ഹുക്കും സജ്ജീകരണ-വേഴ്സസ്-എഫർട്ട് ട്രേഡ്ഓഫും, 98K-സ്റ്റാർ സ്റ്റോറി, ആറ് വർക്ക്ഫ്ലോകളുടെയും പൂർണ്ണമായ ടൂർ, 19-എഞ്ചിൻ കാറ്റലോഗ്, മാക്, വിൻഡോസ്, ലിനക്സ്, ഡോക്കർ എന്നിവയിൽ വൺ-ലൈൻ ഇൻസ്റ്റാൾ, ലൈവ് റിലീസും സ്റ്റാർ-കൗണ്ട് വെരിഫിക്കേഷനും, മിക്ക വീഡിയോകളും ഒഴിവാക്കുന്ന ലൈസൻസ് സത്യസന്ധത, ടിങ്കറർ ടാക്സ് ഉൾപ്പെടെയുള്ള യഥാർത്ഥ പരിധികൾ, ലോക്കൽ API, MCP സെർവർ എന്നിവ ഉപയോഗിച്ച് നിങ്ങളുടെ ഹോംലാബിലേക്ക് അത് എങ്ങനെ വയർ ചെയ്യാം. പൂജ്യം സജ്ജീകരണവും പകരം സാധ്യമായ ഏറ്റവും മികച്ച ശബ്ദ നിലവാരവും തിരഞ്ഞെടുക്കുക? ആ ലെയ്ൻ ElevenLabs ആണ്. അധ്യായങ്ങൾ: 0:00 എന്റെ മെഷീനിൽ റെൻഡർ ചെയ്തു 0:40 വോയ്സ് സ്റ്റുഡിയോ: 98,000 നക്ഷത്രങ്ങൾ, പൂർണ്ണമായും ലോക്കൽ 1:12 ഈ ശബ്ദമാണ് ആപ്പ് 1:36 ക്ലോൺ, ഡിസൈൻ, ഡബ് 2:10 19 സ്പീച്ച് എഞ്ചിനുകൾ, 10 ട്രാൻസ്ക്രിപ്ഷൻ 2:51 ഒരു വരി, ഓരോ പ്ലാറ്റ്ഫോമും 3:28 ലൈവ് പ്രൂഫ്: റിലീസ്, നക്ഷത്രങ്ങൾ, ശബ്ദങ്ങൾ 3:55 സൗജന്യ ആപ്പ്, വെയ്റ്റുകൾ പരിശോധിക്കുക 4:24 സത്യസന്ധമായ പരിധികൾ 5:06 നിങ്ങളുടെ ഹോംലാബിലേക്ക് വയർ ചെയ്യുക 5:36 വിധി: രണ്ട് ലെയ്നുകൾ, നിങ്ങളുടെ കോൾ ഉറവിടങ്ങൾ: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest ലിങ്കുകൾ: s-scottek.com ക്രെഡിറ്റുകൾ: പബ്ലിക് പ്രോജക്റ്റ് പേജുകളിൽ നിന്ന് സ്കോട്ടെക് പകർത്തിയ എല്ലാ സ്ക്രീൻഷോട്ടുകളും. പബ്ലിക് API-കളും പേജുകളും വഴി നക്ഷത്രവും റിലീസ് കണക്കുകളും ഒരേ ദിവസം പരിശോധിച്ചു. വോയ്സ് ഓവർ: സിന്തറ്റിക് ആഖ്യാനം. ലഘുചിത്രം: സ്കോട്ടെക് ബ്രാൻഡ് തരം ഉപയോഗിച്ച് AI- ജനറേറ്റഡ് ഹീറോ ആർട്ട്. #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [nl-NL] Gratis lokale AI-stem: Wat is VoiceStudio? (Handleiding) VoiceStudio is gratis, open source en draait op je eigen computer — met meer dan 98.000 GitHub-sterren. Kloon stemmen, ontwerp stemmen, dub video's, dicteer, transcribeer en spreek audioboeken in meer dan 600 talen in, zonder account en zonder cloud. De gesproken tekst in deze video is lokaal gerenderd door dezelfde app. Wat je hoort, is wat je krijgt. Wat deze video behandelt: de lokale render-hook en de afweging tussen installatie en inspanning, het verhaal achter de 98.000 sterren, een volledige rondleiding door alle zes workflows, de catalogus met 19 engines, installatie met één regel code op Mac, Windows, Linux en Docker, live release en verificatie van het aantal sterren, de licentie-eerlijkheid die de meeste video's overslaan, de echte beperkingen, inclusief de kosten voor knutselaars, en hoe je het in je thuisnetwerk integreert met de lokale API en MCP-server. Liever geen installatie en de best mogelijke spraakkwaliteit? Dan is ElevenLabs de oplossing. Hoofdstukken: 0:00 Gemaakt op mijn computer 0:40 VoiceStudio: 98.000 sterren, volledig lokaal 1:12 Deze stem is de app 1:36 Klonen, ontwerpen, nasynchroniseren 2:10 19 spraakengines, 10 transcripties 2:51 Eén regel, elk platform 3:28 Live bewijs: release, sterren, stemmen 3:55 Gratis app, check de gewichten 4:24 Eerlijke beperkingen 5:06 Sluit het aan op je thuisnetwerk 5:36 Oordeel: twee banen, de keuze is aan jou Bronnen: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest Links: s-scottek.com Credits: alle screenshots zijn gemaakt door Scottek van openbare projectpagina's. Sterren- en releasecijfers zijn dezelfde dag geverifieerd via openbare API's en pagina's. Voiceover: synthetische narratie. Miniatuurafbeelding: Door AI gegenereerde hero-afbeelding met Scottek-merklettertype. #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [pa] ਮੁਫ਼ਤ ਲੋਕਲ ਏਆਈ ਵੌਇਸ: VoiceStudio ਕੀ ਹੈ? (ਗਾਈਡ) VoiceStudio ਮੁਫ਼ਤ, ਓਪਨ ਸੋਰਸ ਹੈ, ਅਤੇ ਤੁਹਾਡੀ ਆਪਣੀ ਮਸ਼ੀਨ 'ਤੇ ਚੱਲਦਾ ਹੈ — 98,000 GitHub ਸਟਾਰਾਂ ਤੋਂ ਵੱਧ। 600+ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਕਲੋਨ ਵੌਇਸ, ਡਿਜ਼ਾਈਨ ਵੌਇਸ, ਡੱਬ ਵੀਡੀਓ, ਡਿਕਟੇਟ, ਟ੍ਰਾਂਸਕ੍ਰਾਈਬ ਅਤੇ ਆਡੀਓਬੁੱਕਾਂ, ਬਿਨਾਂ ਕਿਸੇ ਖਾਤੇ ਅਤੇ ਕਲਾਉਡ ਦੇ। ਇਸ ਵੀਡੀਓ ਵਿੱਚ ਬਿਰਤਾਂਤ ਨੂੰ ਉਸੇ ਐਪ ਦੁਆਰਾ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਰੈਂਡਰ ਕੀਤਾ ਗਿਆ ਸੀ। ਤੁਸੀਂ ਜੋ ਸੁਣਦੇ ਹੋ ਉਹੀ ਤੁਹਾਨੂੰ ਮਿਲਦਾ ਹੈ। ਇਸ ਵਿੱਚ ਕੀ ਸ਼ਾਮਲ ਹੈ: ਲੋਕਲ-ਰੈਂਡਰ ਹੁੱਕ ਅਤੇ ਸੈੱਟਅੱਪ-ਬਨਾਮ-ਕੋਸ਼ਿਸ਼ ਟ੍ਰੇਡਆਫ, 98K-ਸਟਾਰ ਕਹਾਣੀ, ਸਾਰੇ ਛੇ ਵਰਕਫਲੋ ਦਾ ਪੂਰਾ ਟੂਰ, 19-ਇੰਜਣ ਕੈਟਾਲਾਗ, ਮੈਕ, ਵਿੰਡੋਜ਼, ਲੀਨਕਸ ਅਤੇ ਡੌਕਰ 'ਤੇ ਇੱਕ-ਲਾਈਨ ਇੰਸਟਾਲ, ਲਾਈਵ ਰਿਲੀਜ਼ ਅਤੇ ਸਟਾਰ-ਕਾਉਂਟ ਵੈਰੀਫਿਕੇਸ਼ਨ, ਲਾਇਸੈਂਸ ਇਮਾਨਦਾਰੀ ਜੋ ਜ਼ਿਆਦਾਤਰ ਵੀਡੀਓ ਛੱਡਦੇ ਹਨ, ਟਿੰਕਰਰ ਟੈਕਸ ਸਮੇਤ ਅਸਲ ਸੀਮਾਵਾਂ, ਅਤੇ ਇਸਨੂੰ ਸਥਾਨਕ API ਅਤੇ MCP ਸਰਵਰ ਨਾਲ ਆਪਣੀ ਹੋਮਲੈਬ ਵਿੱਚ ਕਿਵੇਂ ਵਾਇਰ ਕਰਨਾ ਹੈ। ਜ਼ੀਰੋ ਸੈੱਟਅੱਪ ਅਤੇ ਸਭ ਤੋਂ ਵਧੀਆ ਸੰਭਵ ਵੌਇਸ ਗੁਣਵੱਤਾ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੇ ਹੋ? ਉਹ ਲੇਨ ElevenLabs ਹੈ। ਅਧਿਆਏ: 0:00 ਮੇਰੀ ਮਸ਼ੀਨ 'ਤੇ ਰੈਂਡਰ ਕੀਤਾ ਗਿਆ 0:40 ਵੌਇਸ ਸਟੂਡੀਓ: 98,000 ਸਟਾਰ, ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਥਾਨਕ 1:12 ਇਹ ਵੌਇਸ ਐਪ ਹੈ 1:36 ਕਲੋਨ, ਡਿਜ਼ਾਈਨ, ਡੱਬ 2:10 19 ਸਪੀਚ ਇੰਜਣ, 10 ਟ੍ਰਾਂਸਕ੍ਰਿਪਸ਼ਨ 2:51 ਇੱਕ ਲਾਈਨ, ਹਰ ਪਲੇਟਫਾਰਮ 3:28 ਲਾਈਵ ਪਰੂਫ: ਰਿਲੀਜ਼, ਸਟਾਰ, ਵੌਇਸ 3:55 ਮੁਫ਼ਤ ਐਪ, ਵਜ਼ਨ ਦੀ ਜਾਂਚ ਕਰੋ 4:24 ਇਮਾਨਦਾਰ ਸੀਮਾਵਾਂ 5:06 ਇਸਨੂੰ ਆਪਣੀ ਹੋਮਲੈਬ ਵਿੱਚ ਵਾਇਰ ਕਰੋ 5:36 ਫੈਸਲਾ: ਦੋ ਲੇਨ, ਤੁਹਾਡੀ ਕਾਲ ਸਰੋਤ: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest ਲਿੰਕ: s-scottek.com ਕ੍ਰੈਡਿਟ: ਸਾਰੇ ਸਕ੍ਰੀਨਸ਼ਾਟ ਸਕਾਟੇਕ ਦੁਆਰਾ ਜਨਤਕ ਪ੍ਰੋਜੈਕਟ ਪੰਨਿਆਂ ਤੋਂ ਲਏ ਗਏ। ਸਟਾਰ ਅਤੇ ਰੀਲੀਜ਼ ਅੰਕੜੇ ਉਸੇ ਦਿਨ ਜਨਤਕ API ਅਤੇ ਪੰਨਿਆਂ ਰਾਹੀਂ ਪ੍ਰਮਾਣਿਤ ਕੀਤੇ ਗਏ। ਵੌਇਸਓਵਰ: ਸਿੰਥੈਟਿਕ ਕਥਨ। ਥੰਬਨੇਲ: ਸਕੌਟੈਕ ਬ੍ਰਾਂਡ ਕਿਸਮ ਦੇ ਨਾਲ AI-ਤਿਆਰ ਹੀਰੋ ਆਰਟ। #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [pl] Darmowy lokalny głos AI: czym jest VoiceStudio? (Poradnik) VoiceStudio jest darmowe, ma otwarte oprogramowanie i działa na Twoim komputerze — ponad 98 000 gwiazdek w serwisie GitHub. Klonuj głosy, projektuj głosy, dubbinguj filmy, dyktuj, transkrybuj i twórz narrację do audiobooków w ponad 600 językach, bez konta i bez chmury. Narracja w tym filmie została wygenerowana lokalnie przez tę samą aplikację. Dostajesz to, co słyszysz. Omówiono: hak renderowania lokalnego i kompromis między konfiguracją a wysiłkiem, historię 98 000 gwiazdek, pełny przegląd wszystkich sześciu przepływów pracy, katalog 19 silników, instalację w jednym wierszu kodu na komputerach Mac, Windows, Linux i Dockerze, wydanie na żywo i weryfikację liczby gwiazdek, uczciwość licencji pomijaną w większości filmów, rzeczywiste ograniczenia, w tym podatek od majsterkowania, oraz sposób podłączenia do domowego laboratorium za pomocą lokalnego API i serwera MCP. Wolisz brak konfiguracji i najlepszą możliwą jakość głosu? Tym rozwiązaniem jest ElevenLabs. Rozdziały: 0:00 Wyrenderowane na moim komputerze 0:40 VoiceStudio: 98 000 gwiazdek, w pełni lokalne 1:12 Ten głos to aplikacja 1:36 Klonowanie, projektowanie, dubbing 2:10 19 silników mowy, 10 transkrypcji 2:51 Jedna linijka, każda platforma 3:28 Dowód na żywo: wydanie, gwiazdki, głosy 3:55 Darmowa aplikacja, sprawdź wagi 4:24 Uczciwe ograniczenia 5:06 Podłącz to do swojego laboratorium domowego 5:36 Werdykt: dwa pasy, twoja decyzja Źródła: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest Linki: s-scottek.com Źródła: wszystkie zrzuty ekranu wykonane przez Scotteka z publicznych stron projektu. Liczba gwiazdek i premier zweryfikowana tego samego dnia za pośrednictwem publicznych interfejsów API i stron. Lektor: narracja syntetyczna. Miniatura: grafika bohatera wygenerowana przez sztuczną inteligencję z czcionką marki Scottek. #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [pt-BR] IA de Voz Local e Gratuita: O que é o VoiceStudio? (Guia) O VoiceStudio é gratuito, de código aberto e funciona na sua própria máquina — com mais de 98.000 estrelas no GitHub. Clone vozes, crie vozes, duble vídeos, dite, transcreva e narre audiolivros em mais de 600 idiomas, sem necessidade de conta ou nuvem. A narração neste vídeo foi renderizada localmente pelo mesmo aplicativo. O que você ouve é o que você obtém. O que este vídeo aborda: o recurso de renderização local e a relação entre configuração e esforço, a história das 98 mil estrelas, um tour completo pelos seis fluxos de trabalho, o catálogo com 19 mecanismos, instalação com um único comando no Mac, Windows, Linux e Docker, lançamento ao vivo e verificação da contagem de estrelas, a honestidade da licença que a maioria dos vídeos ignora, as limitações reais, incluindo o custo adicional para quem gosta de experimentar, e como integrá-lo ao seu laboratório doméstico com a API local e o servidor MCP. Prefere configuração zero e a melhor qualidade de voz possível? Essa é a solução para o ElevenLabs. Capítulos: 0:00 Renderizado na minha máquina 0:40 VoiceStudio: 98.000 estrelas, totalmente local 1:12 Esta voz é o aplicativo 1:36 Clonar, projetar, dublar 2:10 19 mecanismos de fala, 10 transcrições 2:51 Uma linha, todas as plataformas 3:28 Prova ao vivo: lançamento, estrelas, vozes 3:55 Aplicativo gratuito, verifique os pesos 4:24 Limitações honestas 5:06 Integre-o ao seu laboratório doméstico 5:36 Veredito: duas opções, a decisão é sua Fontes: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest Links: s-scottek.com Créditos: todas as capturas de tela foram feitas por Scottek a partir de páginas públicas do projeto. Os números de estrelas e lançamentos foram verificados no mesmo dia por meio de APIs e páginas públicas. Locução: narração sintética. Miniatura: arte principal gerada por IA com a tipografia da marca Scottek. #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [ru] Бесплатный локальный ИИ-голос: что такое VoiceStudio? (Руководство) VoiceStudio — бесплатное приложение с открытым исходным кодом, работающее на вашем компьютере — более 98 000 звёзд на GitHub. Клонируйте голоса, создавайте собственные голоса, озвучивайте видео, диктуйте, транскрибируйте и озвучивайте аудиокниги на более чем 600 языках, без учётной записи и облачных сервисов. Озвучка в этом видео была создана локально тем же приложением. Что вы слышите, то и получаете. Что здесь рассматривается: механизм локального рендеринга и компромисс между настройкой и трудозатратами, история 98 000 звёзд, полный обзор всех шести рабочих процессов, каталог из 19 движков, установка в одну строку на Mac, Windows, Linux и Docker, проверка релиза и количества звёзд, честность лицензий, которую большинство видео пропускают, реальные ограничения, включая «налог на эксперименты», и как интегрировать его в вашу домашнюю лабораторию с помощью локального API и сервера MCP. Предпочитаете нулевую настройку и наилучшее возможное качество голоса? Тогда вам к ElevenLabs. Разделы: 0:00 Отрендерено на моей машине 0:40 VoiceStudio: 98 000 звезд, полностью локальное воспроизведение 1:12 Этот голос — приложение 1:36 Клонирование, дизайн, озвучивание 2:10 19 речевых движков, 10 транскрипции 2:51 Одна строка, каждая платформа 3:28 Живое доказательство: релиз, звезды, голоса 3:55 Бесплатное приложение, проверьте веса 4:24 Честные ограничения 5:06 Подключите его к своей домашней лаборатории 5:36 Вердикт: две полосы, решать вам Источники: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest Ссылки: s-scottek.com Благодарности: все скриншоты сделаны Scottek с общедоступных страниц проекта. Данные о количестве звезд и релизов проверены в тот же день через общедоступные API и страницы. Озвучка: синтетический голос. Миниатюра: сгенерированное ИИ изображение с фирменным шрифтом Scottek. #homelab #selfhosted #localai #opensource #voicestudio #tts #voiceai #linux #docker #ai [ta] இலவச லோக்கல் AI வாய்ஸ்: VoiceStudio என்றால் என்ன? (வழிகாட்டி) VoiceStudio இலவசமானது, திறந்த மூல மென்பொருள், மற்றும் உங்கள் சொந்த கணினியில் இயங்குகிறது — இது 98,000-க்கும் மேற்பட்ட GitHub ஸ்டார்களைப் பெற்றுள்ளது. கணக்கு மற்றும் கிளவுட் எதுவும் இல்லாமல், 600-க்கும் மேற்பட்ட மொழிகளில் குரல்களை நகலெடுக்கவும், குரல்களை வடிவமைக்கவும், வீடியோக்களுக்கு டப்பிங் செய்யவும், சொல்லச் சொல்லவும், படியெடுக்கவும், மற்றும் ஆடியோபுக்குகளுக்கு வர்ணனை செய்யவும் முடியும். இந்த வீடியோவில் உள்ள வர்ணனை, அதே செயலி மூலம் உங்கள் கணினியிலேயே உருவாக்கப்பட்டது. நீங்கள் கேட்பதுதான் உங்களுக்குக் கிடைக்கும். இதில் உள்ளவை: உள்ளூர்-ரெண்டர் ஹூக் மற்றும் அமைப்புக்கும் முயற்சிக்கும் இடையிலான சமநிலை, 98,000 ஸ்டார்களின் கதை, ஆறு பணிப்பாய்வுகளின் முழுமையான விளக்கம், 19-இன்ஜின் பட்டியல், Mac, Windows, Linux, மற்றும் Docker-இல் ஒரே வரியில் நிறுவுதல், நேரடி வெளியீடு மற்றும் ஸ்டார்-எண்ணிக்கை சரிபார்ப்பு, பெரும்பாலான வீடியோக்கள் தவிர்க்கும் உரிம நேர்மை, டிங்கரர் வரி உட்பட உண்மையான வரம்புகள், மற்றும் உள்ளூர் API மற்றும் MCP சர்வர் மூலம் உங்கள் ஹோம்லேபில் இதை எப்படி இணைப்பது. அதற்குப் பதிலாக, எந்த அமைப்பும் இல்லாமல் சிறந்த குரல் தரத்தை விரும்புகிறீர்களா? அந்தப் பாதைக்கு ElevenLabs உள்ளது. அத்தியாயங்கள்: 0:00 எனது கணினியில் உருவாக்கப்பட்டது 0:40 வாய்ஸ்ஸ்டுடியோ: 98,000 ஸ்டார்கள், முழுமையாக உள்ளூர் 1:12 இந்தக் குரலே செயலி 1:36 குளோனிங், வடிவமைப்பு, டப்பிங் 2:10 19 பேச்சு இயந்திரங்கள், 10 டிரான்ஸ்கிரிப்ஷன் 2:51 ஒரு வரி, எல்லா தளங்களிலும் 3:28 நேரடி ஆதாரம்: வெளியீடு, ஸ்டார்கள், குரல்கள் 3:55 இலவச செயலி, வெயிட்டுகளைச் சரிபார்க்கவும் 4:24 நேர்மையான வரம்புகள் 5:06 உங்கள் ஹோம்லேபில் இணைக்கவும் 5:36 தீர்ப்பு: இரண்டு பாதைகள், உங்கள் முடிவு ஆதாரங்கள்: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest இணைப்புகள்: s-scottek.com நன்றிகள்: அனைத்து ஸ்கிரீன்ஷாட்களும் பொது திட்டப் பக்கங்களிலிருந்து ஸ்காட்டெக்கால் எடுக்கப்பட்டவை. ஸ்டார் மற்றும் வெளியீட்டு புள்ளிவிவரங்கள் பொது APIகள் மற்றும் பக்கங்கள் வழியாக அதே நாளில் சரிபார்க்கப்பட்டன. குரல்வழி வர்ணனை: செயற்கை விவரிப்பு. சிறுபடம்: ஸ்காட்டெக் பிராண்ட் எழுத்துருவுடன் கூடிய, செயற்கை நுண்ணறிவால் உருவாக்கப்பட்ட முதன்மைப் படம். #ஹோம்லேப் #சுயஹோஸ்டட் #லோக்கல்ஏஐ #ஓப்பன்சோர்ஸ் #வாய்ஸ்ஸ்டுடியோ #டிடிஎஸ் #வாய்ஸ்ஏஐ #லினக்ஸ் #டாக்கர் #ஏஐ [te] ఉచిత లోకల్ AI వాయిస్: వాయిస్ స్టూడియో (VoiceStudio) అంటే ఏమిటి? (గైడ్) వాయిస్స్టూడియో ఉచితం, ఓపెన్ సోర్స్ మరియు మీ స్వంత మెషీన్లోనే నడుస్తుంది — 98,000 గిట్హబ్ స్టార్లను దాటింది. ఎలాంటి అకౌంట్ మరియు క్లౌడ్ అవసరం లేకుండా, 600+ భాషలలో వాయిస్లను క్లోన్ చేయండి, వాయిస్లను డిజైన్ చేయండి, వీడియోలకు డబ్బింగ్ చెప్పండి, డిక్టేట్ చేయండి, ట్రాన్స్క్రైబ్ చేయండి మరియు ఆడియోబుక్లను వివరించండి. ఈ వీడియోలోని వ్యాఖ్యానం అదే యాప్ ద్వారా స్థానికంగా రెండర్ చేయబడింది. మీరు వినేదే మీకు లభిస్తుంది. ఇందులో కవర్ చేయబడిన అంశాలు: లోకల్-రెండర్ హుక్ మరియు సెటప్-వర్సెస్-ఎఫర్ట్ ట్రేడ్ఆఫ్, 98K-స్టార్ కథ, ఆరు వర్క్ఫ్లోల పూర్తి పర్యటన, 19-ఇంజిన్ కేటలాగ్, Mac, Windows, Linux, మరియు Dockerలో ఒకే-లైన్ ఇన్స్టాల్, లైవ్ రిలీజ్ మరియు స్టార్-కౌంట్ వెరిఫికేషన్, చాలా వీడియోలు విస్మరించే లైసెన్స్ నిజాయితీ, టింకరర్ టాక్స్తో సహా అసలైన పరిమితులు, మరియు లోకల్ API మరియు MCP సర్వర్తో మీ హోమ్ల్యాబ్కు దీన్ని ఎలా కనెక్ట్ చేయాలో. బదులుగా, ఎలాంటి సెటప్ లేకుండా సాధ్యమైనంత ఉత్తమమైన వాయిస్ క్వాలిటీని కోరుకుంటున్నారా? అయితే ఆ మార్గం ఎలెవెన్ల్యాబ్స్. అధ్యాయాలు: 0:00 నా మెషీన్లో రెండర్ చేయబడింది 0:40 వాయిస్స్టూడియో: 98,000 స్టార్స్, పూర్తిగా లోకల్ 1:12 ఈ వాయిస్ యాప్ 1:36 క్లోన్, డిజైన్, డబ్ 2:10 19 స్పీచ్ ఇంజన్లు, 10 ట్రాన్స్క్రిప్షన్ 2:51 ఒకే లైన్, ప్రతి ప్లాట్ఫామ్ 3:28 ప్రత్యక్ష రుజువు: విడుదల, స్టార్స్, వాయిస్లు 3:55 ఉచిత యాప్, వెయిట్స్ తనిఖీ చేయండి 4:24 నిజాయితీ పరిమితులు 5:06 మీ హోమ్ల్యాబ్కు కనెక్ట్ చేయండి 5:36 తీర్పు: రెండు మార్గాలు, మీ ఇష్టం మూలాలు: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest లింకులు: s-scottek.com క్రెడిట్స్: అన్ని స్క్రీన్షాట్లు పబ్లిక్ ప్రాజెక్ట్ పేజీల నుండి స్కాటెక్ ద్వారా తీయబడ్డాయి. స్టార్ మరియు విడుదల గణాంకాలు పబ్లిక్ APIలు మరియు పేజీల ద్వారా అదే రోజు ధృవీకరించబడ్డాయి. వాయిస్ఓవర్: కృత్రిమ కథనం. థంబ్నెయిల్: స్కాటెక్ బ్రాండ్ టైప్తో AI రూపొందించిన హీరో ఆర్ట్. #హోమ్ల్యాబ్ #సెల్ఫ్హోస్టెడ్ #లోకల్ఏఐ #ఓపెన్సోర్స్ #వాయిస్స్టూడియో #టిటిఎస్ #వాయిస్ఏఐ #లినక్స్ #డాకర్ #ఏఐ [uk] Безкоштовний локальний ШІ-голос: що таке VoiceStudio? (Посібник) VoiceStudio — це безкоштовний додаток з відкритим вихідним кодом, який працює на вашому комп’ютері, що має понад 98 000 зірок GitHub. Клонуйте голоси, створюйте дизайн голосів, дублюйте відео, диктуйте, транскрибуйте та озвучуйте аудіокниги понад 600 мовами, без облікового запису та хмарного сховища. Озвучування в цьому відео було відтворено локально тим самим додатком. Ви отримуєте те, що чуєте. Що охоплює: локальний рендеринг та компроміс між налаштуванням та зусиллями, історія 98 тисяч зірок, повний огляд усіх шести робочих процесів, каталог із 19 рушіїв, однорядкове встановлення на Mac, Windows, Linux та Docker, реліз у реальному часі та перевірка кількості зірок, чесність ліцензії, яку пропускає більшість відео, реальні обмеження, включаючи податок на ремонт, та як підключити його до вашої домашньої лабораторії за допомогою локального API та сервера MCP. Натомість віддаєте перевагу нульовому налаштуванню та найкращій можливій якості голосу? Цей шлях — ElevenLabs. Розділи: 0:00 Відрендерено на моїй машині 0:40 VoiceStudio: 98 000 зірок, повністю локально 1:12 Цей голос – це додаток 1:36 Клонування, дизайн, дубляж 2:10 19 мовленнєвих механізмів, 10 транскрипцій 2:51 Один рядок, кожна платформа 3:28 Живий доказ: реліз, зірки, голоси 3:55 Безкоштовний додаток, перевірте ваги 4:24 Чесні обмеження 5:06 Підключіть його до вашої домашньої лабораторії 5:36 Вердикт: дві смуги, ваш вибір Джерела: debpalash/VoiceStudio voicestudio.sh github.com/debpalash/VoiceStudio/releases/latest Посилання: s-scottek.com Авторське право: всі скріншоти зроблені Scottek з публічних сторінок проекту. Дані про зірки та реліз перевірено того ж дня через публічні API та сторінки. Закадровий голос: синтетичний дикторський супровід. Мініатюра: Згенерована штучним інтелектом головна ілюстрація з шрифтом бренду Scottek. #домашнялабораторія #власнийхостинг #локальний #відкритийвихіднийкод #голосовастудія #tts #голосоваінтерфейс #linux #docker #штучнийінтерфейс
✅ 一手来源: GitHub 仓库 README thedotmack/claude-mem GitHub Trending 日榜 github.com/trending 注意:默认安装会引导浏览器登录,用托管记忆服务(30 天试用,之后回落到你的 Anthropic 额度)。不想登录可加 --provider 参数。npm install -g 只装 SDK。
Clash of Clans offline mode for iOS, only 32 bit devices The title says it all Check it out 8133/coc-offline in releases and give a star if you like it Drop screenshots of gameplay if you can, and a rating for thework!
I made an extension to make tracking grades in Canvas easier I made CanvasGradesPro a while ago because I got tired of calculating my grades manually. Some of my courses didn't have assignment weights set up in Canvas, and others hid the overall grade entirely, so it was hard to tell where I stood. It works with Canvas at all universities (to my knowledge), so I thought I'd share it here. The extension adds a few things to Canvas: - Shows your course grades directly on the dashboard, even when the total is hidden - Lets you customize assignment weights, drop rules, and grading scales - Calculates what you need on an assignment or final to reach a certain grade - Tracks your semester and cumulative GPA If you run into any bugs or have suggestions, let me know! Chrome | Firefox | Edge | GitHub
Prism 1.8.0 is out: Prism on your TV, and a lot more Prism 1.8.0 is out, the first of the 1.8 updates, and Prism now runs on your TV. Prism TV (Android TV and Google TV) - The same app with screens made for a remote: your Home (every row you have on your phone, arranged your way), Search with the remote’s mic, your Library, and a big player. - Word-by-word lyrics in your lyrics style, a timing control right on the lyrics, and lyrics over music videos. - Sing on the big screen, now on mid-range TVs too. - When you put the remote down, a calm ambient screen with the song and its lyrics. - Your phone signs the TV in and becomes its remote: pair once over Wi-Fi (an encrypted link). - Play on the TV in sync, like casting: pick your TV in Play on, and your phone controls it. Skip, pause, seek or queue songs on your phone and it happens on the TV, and the TV’s remote shows on your phone. - Bring your Prism to the TV: your history, likes and playlists, so it knows you from day one. - Getting it on your TV: type 8986606 into the Downloader app, or turn on “Share Prism with a TV” in Settings on your phone. On your phone - Settings, made clearer: settings that belonged together are one choice now, each in one place. Nothing you had set changes, and search still finds settings by their old names. - The player, your way: tap any part of the player to hide it, and arrange the ⋯ menu. - Lyrics in four parts: start from a look, then pick the animation, text, background and effects. - For the holidays: Harvest (November) and Holiday (December) Looks with their own illustrations and colors, plus holiday mixes on Home in season (Thanksgiving Dinner, Friendsgiving, Christmas Classics, Christmas Jazz, Navidad Latina and more). - Better search: Better Search Results for songs - Also: desk mode while charging, the tab bar’s place on tablets, a smaller download (about 27 MB with the TV app), quiet songs as loud as the rest, silence trimmed only at a song’s ends, and a long list of fixes from your reports. If you used handoff between two Prism devices before, pair them once more: the link is encrypted now. Found a bug or have an idea? The best way to reach me is GitHub: github.com/Yigder/Prism/issues/new/choose ⬇ Download: github.com/Yigder/Prism/releases/latest/download/… (or tap the update banner in Prism) ☕ If Prism makes your day better: ko-fi.com Thank you all for the support. Most of what’s in Prism started as one of you asking for it.
✅ 一手来源: GitHub 仓库 README(MIT 协议) scenario-labs/skills 注意:多数 skills 通过 Scenario MCP 调用,生成要按 Scenario 计费。驱动 Blender 等软件的专家工具不走 MCP,但本机要装好对应软件。「80 个 skills」为官方自述。
@web3privacy @EFF @farzanehbad and if you too would like to be a giant floating glowing head in your next remote call, here is the code: dannyob/obs-lsd . If all terminalvalues.org manages to do is to make zoom meetings more psychedelic, we will have won
Location: Croatia (EU) Remote: Yes (EU/Worldwide) Willing to relocate: No Technologies: Swift, SwiftUI, UIKit, Objective-C, iOS architecture, performance optimization, product development, UX/design Résumé/CV: tinyurl.com LinkedIn: linkedin.com GitHub: github.com/tomislav Email: tomislav@me.com Senior iOS & Product Engineer with 18+ years of iOS development and 20+ years of software engineering experience. I’ve led development of award-winning apps featured by Apple, The New York Times, and Forbes, and have worked remotely with distributed teams for over a decade. I’m looking for Senior/Lead native iOS roles where I can own product quality from architecture through implementation, with a strong focus on performance, user experience, and shipping polished apps.
Offline PDF Toolbox - an Android PDF toolkit with no INTERNET permission I built a PDF reader and toolbox for Android that works fully offline. Your files stay on your phone unless you share them yourself. What it does: read PDFs, images to PDF, merge, split, reorder, rotate, compress, watermark, redact and on-device OCR. Why I made it this way: - No INTERNET permission. The build fails if a capability-granting permission survives manifest merging, and CI checks the APK on every push. - Redaction is real: the page is rendered to pixels, the selection is painted black, and the page is rebuilt from that image. A black box over live text is rejected by a test. - Open source (MIT). Cost: free, no ads. There are optional paid support options through Google Play. Built solo from Türkiye with help from an AI coding agent (Claude). English and Turkish UI. Feedback welcome. Google Play: play.google.com GitHub: bilalfarukozdemir/pdf-kutusu
@VinceP1974Chi Go for it, it's free to try. You just plug in your own API key: w6liam/OSSFlow
Concurrent denylist exports can overwrite newer bans. @coderabbitai caught the race; a shared lock now serializes read, write, and reload. Try CodeRabbit for reviews that catch the tricky stuff 🔒 laravel-scanner-guard#27
I made a native Linux RGB lighting driver and interactive 3D control studio for my Acer laptop Finally sharing something I've been working on! Meet Luma ALG RGB. I built this because I wanted proper RGB keyboard control on my Acer Aspire Lite AL15G-52 while using Linux. Instead of making just another RGB application, I developed a complete control stack: - Native DKMS kernel driver. - Direct Acer ACPI hardware communication. - Five-zone RGB control. - Multiple motion and lighting effects. - Interactive 3D keyboard visualization. - Browser-based local dashboard. - Command-line controls. - GNOME Shell extension. One of my favourite parts is having both low-level hardware control and a visual interface in the same project. It's open source under GPL-2.0. Project: chiragkoyande/luma-alg_rgb Tested on Acer Aspire Lite AL15G-52. Would love to hear what other developers think, especially anyone interested in Linux hardware support, kernel development or reverse engineering.
@Cannibal you can get it here: BubblegumTuning/levari Just be aware that I have only really tested the Linux builds.
@ferron_web chinmay-sawant/blinkless chinmay-sawant.github.io This is the project which I am working on, I was just making wkhtmltopdf alternative (gowkhtmltopdf) I noticed I actually build a rendering engine in pure golang, So I thought why can't I just use this as the rendering engine + will create something for a native application in pure golang with HTML and CSS That was my idea behind it
Download it free (no account, ads or tracking): xorvio.com The code: atomtanstudio/xorvio It’s v0.1, so tell me what breaks. And if you like it, a ⭐ on GitHub genuinely helps a solo dev get seen.
AirsupHQ/simready-factory await addFactory(scene) and you get a V8 engine line: 7 stations, 9 robots, 4 AMRs, a forklift and a line speed knob, all running. MIT, WebGL or WebGPU.
Antes eram só 2 loucos - Lula e Maluhy - pedindo SELIC 1D Agora são 10MM Chegando a 20MN acontece #selic1D @grok ensina criança entender gostar e usar scoobiii/selix
Your AI writes code. Can it reverse-engineer it? REI REA brings 12 evidence-first skills to REI Skills: binaries, APKs, firmware/IoT, Electron, WASM & protocols. 895 skills. 21 AI targets. Live: rootcastleco.github.io Star: rootcastleco/rei-skills #ReverseEngineering
Location: Tennessee, US Remote: Yes Willing to Relocate: Based on offer Technologies: TypeScript, React, .NET, JavaScript, C#, Python, SQL, ABAP, Java Resume/CV: linkedin.com (Check LinkedIn if Link doesn't work) LinkedIn: linkedin.com GitHub: github.com/EvasiveAce Newgrounds: newgrounds.com Email: hensley.ethan64@gmail.com Software Developer / Technical Analyst with 3+ years of experience across full-stack development, front-end development, system integrations, and data analysis. I have hands-on experience with TypeScript, React, JavaScript, C#, .NET, Python, SQL, ABAP, and REST APIs, with a strong focus on understanding requirements, working with data, troubleshooting issues, and building solutions that connect systems and people. I’m currently based in Tennessee and open to remote opportunities, as well as relocation for the right opportunity. I’m especially interested in software development, technical analysis, integrations, and other roles where I can continue growing technically while solving meaningful problems. Outside of work, I enjoy building software and developing games. You can check out some of my projects on GitHub and my Newgrounds game, Mo' Rockets. Feel free to reach out if you know of an opportunity that could be a good fit!
I Sandboxed My AI Coding Agent with Bubblewrap. It Still Read My Secrets Three Decisions, Three Places Same agent. Same sandbox. Different folder. Different blast radius. Coding agents run real commands on your machine. A README, an issue or a dependency can steer what they run. I kept seeing posts saying agents behave differently depending on where you launch them: /, ~ or ~/dev. I wanted to know why at the kernel level, not just that they do. So I wrapped a minimal coding agent in a sandbox I built myself, traced every process it started, and asked one question about every result: which flag decided this, and where in the kernel does that decision happen? The short version: a bubblewrap sandbox answers three separate questions in three separate places. - Can it write? Decided by the mount the path lives on. - Can it read? Decided by the file's owner and mode bits, the same as outside the sandbox. - Can it talk? Decided by the network namespace the process is in. My policy controlled the first one well. The other two leaked in every run where the agent could work at all. --- The Setup | Piece | What I used | |---|---| | OS | Ubuntu 24.04 LTS on a throwaway cloud VM, everything run as root | | Agent | pi v1.4.0. A deliberately minimal agent with no built-in sandbox or permission prompts | | Model | DeepSeek (deepseek-v4-flash) | | Sandbox | bubblewrap (bwrap), the sandboxing tool Flatpak uses | | Observer outside | bpftrace, logging every program the agent starts, with its namespace IDs | | Observer inside | nsprobe, a small script the agent runs to report what it can see, write, read and reach | | Canary | A fake credential at ~/.fake-creds/token, standing in for ~/.ssh or ~/.aws | pi runs everything with your full access. Whatever sandbox it gets is the one you build, which makes it a clean subject. > Note on Ubuntu 24.04: AppArmor blocks unprivileged user namespaces by default, so bwrap fails for normal users until you add a small AppArmor profile for it in /etc/apparmor.d/bwrap. --- The Policy, Flag by Flag This is the whole sandbox, saved as sandbox-agent: args=( --ro-bind / / # whole filesystem visible, read-only --dev /dev # minimal device nodes --proc /proc # fresh /proc: only sandboxed processes listed --tmpfs /tmp # private, empty /tmp --bind "$PWD" "$PWD" # the launch directory is writable --bind "$HOME/.pi" "$HOME/.pi" # the agent's own state --unshare-pid # own PID namespace --unshare-ipc --unshare-uts # own IPC objects and hostname --die-with-parent # tear down if the launcher dies --chdir "$PWD" ) # NET=off also unshares the network namespace [[ "${NET:-on}" == "off" ]] && args+=(--unshare-net) exec bwrap "${args[@]}" "$@" <br> <br> !What each bwrap flag does to the filesystem and namespaces pi sees How bwrap turns these flags into a sandbox It helps to know what bwrap actually does with that list, because every result later comes back to it: 1. It creates new namespaces. One for mounts, plus one for each --unshare-* flag. Anything not unshared, like the network here, stays shared with the host. 2. It builds a new root from nothing. The new mount namespace starts with an empty tmpfs root that the host never sees. 3. It applies the filesystem flags in order. --ro-bind / / goes in first, as the base layer. Every later flag mounts on top of it. The bwrap man page says it directly: filesystem options are applied in the order they are given. That's why --bind "$PWD" can be writable inside a read-only root. 4. It switches into that root with pivot_root, so the host's real mounts are no longer reachable. 5. It drops capabilities. From the man page: "By default no caps are left in the sandboxed process." Even as root. 6. It runs the command. Keep steps 3 and 5 in mind. They explain most of what follows. --- The Observers Giving the agent its own cgroup To trace only the agent, it needs something that marks its processes apart from everything else on the VM. I launched pi with systemd-run: > systemd-run "may be used to create and start a transient .service or .scope unit and run the specified COMMAND in it." With --scope, the command runs in the foreground in a transient scope, and every scope gets its own cgroup. PI="pi --provider deepseek --model deepseek-v4-flash" # Run A: no sandbox systemd-run --user --scope --unit=agent-A -- $PI # Runs B-D: the same, wrapped in the sandbox systemd-run --user --scope --unit=agent-B -- sandbox-agent $PI bubblewrap doesn't move processes between cgroups, so everything pi and the sandbox spawn stays in that scope's cgroup. That's the handle the tracer filters on. The tracer: agent-exec.bt BEGIN { printf("%-7s %-7s %-3s %-11s %-11s %-11s %-11s %s\n", "PID", "PPID", "LVL", "PIDNS", "MNTNS", "NETNS", "USERNS", "FILE"); } tracepoint:sched:sched_process_exec / cgroup == cgroupid("CGROUP_PATH") / { $t = curtask; printf("%-7d %-7d %-3d %-11u %-11u %-11u %-11u %s\n", pid, // PID as the host sees it $t->real_parent->tgid, // parent PID, host view $t->thread_pid->level, // PID ns depth: 0 = host, 1 = nested $t->nsproxy->pid_ns_for_children->ns.inum, // PID ns its children get $t->nsproxy->mnt_ns->ns.inum, // mount namespace $t->nsproxy->net_ns->ns.inum, // network namespace $t->cred->user_ns->ns.inum, // user namespace str(args->filename)); // binary that was exec'd } <br> What each part does: - BEGIN { ... } runs once when bpftrace starts and prints the column header. - tracepoint:sched:sched_process_exec is a fixed hook in the kernel that fires every time a process successfully replaces itself with a new program (execve). One event per program started, which is exactly the "what did the agent run" question. - / cgroup == cgroupid("CGROUP_PATH") / is a filter that runs inside the kernel. cgroup is the cgroup ID of the process that triggered the event, and cgroupid() turns the scope's path under /sys/fs/cgroup into that ID when the script starts. Events from everything else on the VM are dropped before they reach userspace. CGROUP_PATH is a placeholder I replaced with sed for each run. - $t = curtask is a pointer to the kernel's own record of the process (struct task_struct). bpftrace can walk its fields because the kernel ships its type layouts as BTF in /sys/kernel/btf/vmlinux. - pid and real_parent->tgid are the process and its parent, as the host numbers them. - thread_pid->level is how deep the process's PID namespace is nested: 0 for the host, 1 for one sandbox in. This is the LVL column. - nsproxy->..._ns->ns.inum reads the namespace IDs. nsproxy is the per-process bundle of namespace pointers, and ns.inum is the same inode number ls -l /proc/<pid>/ns shows. - cred->user_ns comes from the process's credentials instead of nsproxy, because user namespaces are tied to who you are, not just to what you see. - str(args->filename) is the path of the program being started. The namespace IDs only mean something next to a baseline. This is my own shell's, outside everything (I covered how these IDs work in Isolation in Containers): root@krish-dev:~# cat baseline-ns.txt ... lrwxrwxrwx 1 root root 0 Oct 27 02:57 mnt -> mnt:[4026531841] lrwxrwxrwx 1 root root 0 Oct 27 02:57 net -> net:[4026531840] lrwxrwxrwx 1 root root 0 Oct 27 02:57 pid -> pid:[4026531836] lrwxrwxrwx 1 root root 0 Oct 27 02:57 user -> user:[4026531837] The probe: nsprobe nsprobe reports what the process running it can see and do: its identity, PID and namespaces, how many processes it can see, whether it can write in four places, read the fake token and make a direct HTTPS call. pi runs it, so it inherits whatever sandbox pi is in. #!/usr/bin/env bash # nsprobe: report what the calling process can see and do. # Run it through the agent so it inherits the agent's sandbox (or lack of one). echo "== identity" echo "user=$(id -un) cwd=$PWD" echo "== pid as seen from this /proc (a small number = own PID namespace)" grep NSpid /proc/self/status echo "== namespace ids (compare with baseline-ns.txt)" for ns in pid mnt net user uts ipc cgroup; do printf '%-7s %s\n' "$ns" "$(readlink /proc/self/ns/$ns)" done echo "== processes visible" ls -d /proc/[0-9]* 2>/dev/null | wc -l echo "== write tests (error text says who blocked it)" # "Read-only file system" -> sandbox mount rules # "Permission denied" -> ordinary Unix permissions for f in "$PWD/.nsprobe" "$HOME/.nsprobe" "$HOME/.bashrc" "${TMPDIR:-/tmp}/.nsprobe"; do if err=$(touch "$f" 2>&1); then echo "OK $f" else echo "FAIL $f (${err##*: })" fi done # touch on ~/.bashrc only bumps its timestamp; remove the probe files we created rm -f "$PWD/.nsprobe" "$HOME/.nsprobe" "${TMPDIR:-/tmp}/.nsprobe" 2>/dev/null echo "== read test (fake credential)" head -c 40 "$HOME/.fake-creds/token" 2>&1; echo echo "== direct network (bypassing any proxy)" curl -s --noproxy '*' -m 5 -o /dev/null -w 'HTTP %{http_code}\n' https://example.com \ || echo "no direct route" The write tests print the error text, because the error tells you who said no: | Error | Who blocked it | |---|---| | Read-only file system (EROFS) | The mount. That's the sandbox | | Permission denied (EACCES) | The file's owner and mode bits. That's ordinary Unix permissions | What NSpid tells you Both the probe and the sleep check later rely on one line in /proc/<pid>/status: - PID namespaces nest. A process in a sandbox belongs to the sandbox's PID namespace and to every namespace above it, and it has a separate PID in each one. - NSpid lists all of them, from the outermost to the innermost. The outermost is the namespace of whoever mounted the /proc you're reading. - One value means one namespace. On the host, an ordinary process shows just its host PID. - Two values means one level of nesting: the host's number first, then the number inside the sandbox, which counts from 1. - Inside the sandbox you only see the inner number. The sandbox's /proc was mounted from inside, so its outermost level is the sandbox itself. That's why the probe prints a small number like 17. - It's the same depth as the tracer's LVL. thread_pid->level is the kernel's count of how many levels sit above the innermost one. Then I did four runs. --- Run A - No Sandbox pi was launched from ~/dev/demo with nothing around it. !Run A: every check reaches the host The tracer: PID PPID LVL PIDNS MNTNS NETNS USERNS FILE 20960 20921 0 4026531836 4026531841 4026531840 4026531837 /usr/bin/ls 20962 20961 0 4026531836 4026531841 4026531840 4026531837 /usr/bin/which 20963 20961 0 4026531836 4026531841 4026531840 4026531837 /usr/local/bin/nsprobe The probe: == identity user=root cwd=/root/dev/demo == pid as seen from this /proc (a small number = own PID namespace) NSpid: 20991 == namespace ids (compare with baseline-ns.txt) pid pid:[4026531836] mnt mnt:[4026531841] net net:[4026531840] user user:[4026531837] uts uts:[4026531838] ipc ipc:[4026531839] cgroup cgroup:[4026531835] == processes visible 104 == write tests (error text says who blocked it) OK /root/dev/demo/.nsprobe OK /root/.nsprobe OK /root/.bashrc OK /tmp/.nsprobe == read test (fake credential) FAKE-TOKEN-do-not-use == direct network (bypassing any proxy) HTTP 200 What I observed in run A - Same namespaces as my shell. LVL was 0, and every namespace ID matched the baseline. - NSpid had a single value, 20991. One value means one PID namespace: the host's. - 104 processes visible. That's every process on the VM. - Every write succeeded, ~/.bashrc included. With no mount namespace, the paths are the real files on disk. - The token was readable and HTTPS got out, as expected with nothing in the way. - The agent ran the probe before it knew what it was. Its first move was which nsprobe; nsprobe --help 2>&1 | head -50. nsprobe ignores arguments, so --help ran the whole probe: the writes, the token read and the outbound call. pi only noticed afterwards: "nsprobe --help doesn't print help — it just runs the probe itself." - The same pattern showed up in every run. In run C, pi's reasoning said "Let me check if nsprobe exists", and the check was which nsprobe; nsprobe 2>&1 | head -50. In run B, it ran the probe straight away and only then thought "this is a suspicious command name. Let's look at it." > Without a sandbox, the agent is simply you. And an agent's "look before you leap" is usually a leap: its exploring is real execution, so whatever protection you add has to hold for that too, not just for the command you asked for. --- Run B - Sandboxed, from the Project Directory Same launch directory, with pi inside the sandbox. !Run B: writes outside the project fail; the token and network still get out The tracer, trimmed: PID PPID LVL PIDNS MNTNS NETNS USERNS FILE 21271 21270 1 4026532336 4026532333 4026531840 4026531837 /usr/local/bin/nsprobe 21272 21271 1 4026532336 4026532333 4026531840 4026531837 /usr/bin/id 21274 21271 1 4026532336 4026532333 4026531840 4026531837 /usr/bin/readlink ... 21284 21283 1 4026532336 4026532333 4026531840 4026531837 /usr/bin/touch 21293 21271 1 4026532336 4026532333 4026531840 4026531837 /usr/bin/curl 21601 21600 1 4026532336 4026532333 4026531840 4026531837 /usr/bin/sleep The probe: == identity user=root cwd=/root/dev/demo == pid as seen from this /proc (a small number = own PID namespace) NSpid: 17 == namespace ids (compare with baseline-ns.txt) pid pid:[4026532336] mnt mnt:[4026532333] net net:[4026531840] user user:[4026531837] uts uts:[4026532334] ipc ipc:[4026532335] cgroup cgroup:[4026531835] == processes visible 6 == write tests (error text says who blocked it) OK /root/dev/demo/.nsprobe FAIL /root/.nsprobe (Read-only file system) FAIL /root/.bashrc (Read-only file system) OK /tmp/.nsprobe == read test (fake credential) FAKE-TOKEN-do-not-use == direct network (bypassing any proxy) HTTP 200 Then I asked pi to run sleep 60 and looked it up from the host: root@krish-dev:~# grep NSpid /proc/$(pgrep -n sleep)/status NSpid: 21601 42 What I observed in run B - New PID, mount, UTS and IPC namespaces. Network, user and cgroup unchanged. The PID and mount IDs (4026532336, 4026532333) differ from the host's, and so do UTS and IPC. The network (4026531840), user and cgroup IDs are identical to my shell's. Only the flags I passed created namespaces, and I never passed --unshare-net. - One command, 18 programs, all inside. That single nsprobe started id, grep, seven readlinks, ls, wc, four touches, rm, head and curl. Every one inherited the same namespaces. A sandbox applies to a process and everything it ever spawns. - ~/.bashrc failed with Read-only file system, even as root. --ro-bind / / doesn't change any file. It puts a read-only flag on the mount, and before any write the kernel checks whether the mount is writable. That check ignores your UID and capabilities. On top of that, bwrap dropped every capability before starting pi, so root inside can't remount / (needs CAP_SYS_ADMIN) or override permissions (needs CAP_DAC_OVERRIDE). - The project write worked, and landed on the real disk. --bind "$PWD" came after --ro-bind / /, so it was mounted on top at /root/dev/demo. When the kernel resolves a path and reaches a mount point, it uses the topmost mount there. A bind mount isn't a copy. It's the same directory, visible in a second place. - The /tmp write worked, but never reached the host. --tmpfs /tmp mounts a new, empty, in-memory filesystem on top. The file existed only inside the sandbox and disappeared when it exited. - The fake token was still readable. Reading never asks the mount for write access, so the read-only flag never comes into play. A read is checked only against the file's owner and mode bits, the same as outside the sandbox. The token is owned by root, and the process was UID 0. A read-only bind controls what can change, not what can be seen. - 6 processes, and one process with two PIDs. That takes two flags. --unshare-pid gives the sandbox its own PID numbering, so the host's 21601 is 42 inside. --proc /proc mounts a new procfs, and a procfs lists only "processes visible in the PID namespace of the process that performed the mount" (pid_namespaces(7)). Without --proc, the recursive --ro-bind / / would have brought in the host's /proc, and the probe would have counted 104 again. - HTTPS still got out. pi stayed in the host's network namespace, with the same interfaces and routes. DNS worked because /etc/resolv.conf was readable through the read-only root and pointed at the systemd-resolved stub on 127.0.0.53, which sits on the shared loopback. > The sandbox controlled writes well, because writes are a mount question and mounts were what I configured. It didn't control reads, because reads aren't a mount question. And it didn't control the network, because I never unshared it. As far as secrets and the network go, run B is run A. --- Run C - Same Sandbox, Launched from ~ The policy didn't change. Only the directory I started from did. ![Run C: launched from ~, ~/.bashrc becomes writable] (dev-to-uploads.s3.us-east-2.amazonaws.com) The probe: == identity user=root cwd=/root == pid as seen from this /proc (a small number = own PID namespace) NSpid: 44 == namespace ids (compare with baseline-ns.txt) pid pid:[4026532334] mnt mnt:[4026532330] net net:[4026531840] user user:[4026531837] uts uts:[4026532331] ipc ipc:[4026532333] cgroup cgroup:[4026531835] == processes visible 5 == write tests (error text says who blocked it) OK /root/.nsprobe OK /root/.nsprobe OK /root/.bashrc OK /tmp/.nsprobe == read test (fake credential) FAKE-TOKEN-do-not-use == direct network (bypassing any proxy) HTTP 200 What I observed in run C - Still sandboxed. New PID and mount namespaces (fresh IDs, since it's a new sandbox), NSpid of 44 and 5 processes visible. Network and user namespaces unchanged again. - OK /root/.nsprobe appears twice. $PWD and $HOME were both /root, so the probe's first two write tests hit the same file. - Every write succeeded, ~/.bashrc included. --bind "$PWD" "$PWD" now meant --bind /root /root. That writable mount sat on top of the read-only root at /root, so everything under it resolved to a writable mount: dotfiles, ~/.fake-creds, and ~/.ssh if it existed. The ~/.pi bind on top became redundant. - A writable ~/.bashrc is a way out of the sandbox. Whatever the agent appends runs the next time you open a shell, outside the sandbox, as you, with every capability bwrap took away. The probe only touched the file. A prompt-injected command wouldn't stop there. - The token and network behaved exactly as in run B. > The policy didn't change, but its input did. A sandbox that binds $PWD turns the launch directory into part of the policy. That's the real explanation behind the "different behavior in / vs ~ vs ~/dev" posts: launch this script from / and the whole disk is writable. --- Run D - Cutting the Network NET=off adds --unshare-net, so the sandbox gets a new, empty network namespace. I asked pi to run the probe again: !Run D: with the network cut, pi never reached its model and nothing ran Error: Connection error. Error: Connection error. Error: Connection error. Error: Connection error. Error: Retry failed after 3 attempts: Connection error. What I observed in run D - pi never ran a single command. The tracer log for this run had only its header. - The new network namespace had only a loopback interface. No route out. The resolver at 127.0.0.53 lives on the host's loopback, not the new one, so most likely even the DNS lookup for the API failed. - The agent and its commands share one network namespace. A namespace belongs to a process, and children inherit it. Wrapping the whole agent puts its API calls inside the same boundary as its commands. There's no flag that says "pi may reach api.deepseek.com but its curl may not". - This is why per-command sandboxing exists. Claude Code sandboxes each shell command instead of the whole agent. On Linux, each command runs in a network namespace with no route out, and its traffic goes through a proxy on the host that checks domains against an allowlist. > Cutting the network worked perfectly, and that was the problem. When you wrap the whole agent, you can't cut its commands off from the internet without cutting the agent off from its model. --- What Each Flag Actually Decided | Question | Decided by | Flag in my policy | What I saw | |---|---|---|---| | Can it write here? | The mount at that path: read-only or not | --ro-bind / /, then --bind on top | EROFS outside the binds, even as root | | Where does a write land? | Bind (host disk) or tmpfs (memory) | --bind "$PWD", --tmpfs /tmp | Project writes hit the real disk; /tmp writes vanished | | How much is writable? | The value of $PWD | --bind "$PWD" "$PWD" | From ~, the whole home, .bashrc included | | Can it read this? | File owner and mode bits | None. A read-only bind doesn't apply to reads | Fake token read in every run | | Can it see other processes? | PID namespace and which /proc is mounted | --unshare-pid + --proc /proc | 6 processes instead of 104; PID 42 vs 21601 | | Can it reach the network? | Network namespace | --unshare-net, only when NET=off | Open in A–C; in D, the agent itself went dark | | Can root override any of it? | Capabilities | bwrap drops all of them by default | No remount, no permission override | > Note on running as root: I ran everything as root on the VM, so bwrap didn't need a user namespace and the user namespace ID never changed. As a normal user, bwrap creates one to get the privileges it needs to build the sandbox, which is what the AppArmor change is for. The token result would be the same: you'd own the token, so you could read it. Treat these as lab numbers, not a production setup. What this policy doesn't do at all Three things never came up in the probe, but they're worth knowing: - No syscall filter. There's no seccomp profile, so every system call is available. The sandbox shares the host kernel, and a kernel bug is a way out. - No resource limits. bwrap doesn't touch cgroups. A runaway build or a fork bomb inside the sandbox uses your machine's CPU and memory. The systemd-run scope I used for tracing is the natural place to add limits like -p MemoryMax=. - No protection for what's already writable. Everything in the project directory can be read, changed or deleted. The sandbox protects the rest of the machine, not your work. --- Putting It Together The sandbox did exactly what I told it to. The problem was what I didn't know I was telling it: - Writes are decided by mounts. --ro-bind and --bind gave me real control here, but the launch directory quietly decides how much is writable. - Reads are decided by ownership, exactly as outside the sandbox. A read-only bind exposes everything it brings in. - The network is decided by a namespace the agent itself needs, so wrapping the whole agent can't close it. Namespaces held the boundary in every run. The leaks were all in my policy: a read-only bind over secrets, a launch directory that was too wide, and a network that had to stay open for the agent to work. A sandbox makes mistakes smaller, not impossible. It still shares your kernel. --- References - bubblewrap - GitHub and its bwrap(1) man page - systemd-run(1) - bpftrace - pid_namespaces(7), proc_pid_status(5) for NSpid - mount_namespaces(7), network_namespaces(7) - Configure the sandboxed Bash tool - Claude Code docs - Isolation in Containers. Linux Primitives that help Achieve It
I made an Anno 117 Companion for PC and mobile Hey governors! I wanted a clearer view of my empire without constantly digging through statistics, so I built **Anno 117 Companion** and have just released it for free. It reads the game’s production statistics through the `/pipe` interface and brings them together in a dashboard you can use on your PC or phone. It runs as a **Windows app**, with the same dashboard available in an **Android app** or a **local browser on an iPhone, tablet or another computer**. Android also has a home-screen widget, so you can check supply suggestions without opening the app. Here's what it does: * **Production across your islands:** see production, consumption, local shortages and surpluses by island or product. * **Supply suggestions:** find where one island's surplus could help another, then turn a suggestion into a route plan. * **Trade-route planning:** several goods on one ship, multiple stops, manually entered cargo quantities and a cargo-slot capacity check. Plans are shared through the PC Companion in Live mode. * **Production chains:** browse by region, population tier, good or DLC, with building ratios, productivity and relevant specialists. * **Build locally or import:** production suggestions respect regions. If an Albion island needs Olives, you can plan production in Latium and import back to the original island. * **Needs and reports:** explore tier needs, record what you've checked in game, and export an illustrated empire summary PDF. The newspaper icon on Home is a small easter egg. :) The interface supports **12 languages**. There's also a Demo mode to explore before connecting your game. [**Downloads, screenshots and setup instructions — GitHub**](oriskoat/anno117companion) [**Windows EXE / Android APK — v0.20.0**](github.com/oriskoat/anno117companion/releases/tag…) **How Live works:** enable `/pipe` in Anno's launch options, restart the game, load a save, let the simulation run and open Production Statistics. The Windows Companion must stay running. Other devices connect over your local network using a QR code or the displayed PC address and a six-digit pairing code. No Windows password is needed. **Paused game?** No new statistics arrive while paused. Once data has been received, the Companion keeps showing the last values and their age. It updates again when the game publishes new statistics. One important distinction: these are **local production balances and manual plans**. The pipe doesn't report warehouse stock, existing shipping routes or actual residential service coverage. A local deficit may already be covered by your ships. The Companion doesn't control the game or create routes for you. It's an unofficial community tool, not affiliated with Ubisoft. Windows 10/11 x64 and Android 8.0+; iPhone uses the local browser interface rather than a native iOS app. The Windows EXE is currently unsigned. The source is on GitHub too. The app is free. If you enjoy it and would like to support my work, you’ll find an optional coffee link on GitHub and in the app. No tribute required. ☕ See you next week with updated data for Aegyptus 🐊 preview.redd.it I'd love feedback — especially from people with larger empires. Are the supply suggestions useful? Is anything confusing, missing, or behaving differently on your device?
Location: New Jersey, USA (NYC metro) Remote:Yes, or NYC hybrid Willing to relocate: No Technologies: TypeScript, JavaScript, React, Ember.js, Node.js, Python, Storybook, Playwright, Chrome extensions, Core Web Vitals, WCAG Résumé/CV: https://brianinteractive.com/BrianEngResume.pdf (GitHub: https://github.com/brianeng00) Email: brianeng87 [at] gmail [dot] com Senior frontend engineer, 11 years in. Most recently at Wunderkind, where my code ran on other people's high-traffic websites under strict delivery SLAs. I owned our shared integration library, kept Core Web Vitals from regressing, and built a React/TypeScript Chrome extension that cut our integration testing time by 70%. I'd like my next job to be on frontend platform, developer tooling, design systems, or data viz, somewhere other engineers build on what I ship. Since leaving I've been building on my own. FlightTrack is a real-time flight tracker in React 19 and MapLibre. I use Claude Code and other AI agents a lot, but I don't ship anything I can't explain.
Top Spin 4 native PC port is out, and it wouldn't exist without Xenia (4K trailer) Hey everyone, I've been working on a native PC port of Top Spin 4 and it's out now. It's a static recompilation, so the game runs as a normal Windows program instead of inside an emulator, and for me it runs better than it does in Xenia. That said, Xenia helped me a huge amount to make this. I had Xenia Edge and Canary open next to it the whole time to compare against, and one of the two renderers in the port still emulates the GPU the way Xenia does. So big thanks to everyone who worked on Xenia over the years, this port stands on your work. You can play it in 4K with MSAA and 60 fps cutscenes. Career, exhibition, King of the Court and local multiplayer all work, online doesn't. It's free, here is the github: shaneomac1337/Top-Spin-4-Recomp Let me know how it runs for you, I only tested it on AMD so far.
My Acer laptop's RGB keyboard was difficult to control on Linux, so I built a native driver and 3D studio I wanted to control my Acer Aspire Lite AL15G-52's RGB keyboard directly from Linux. The usual approach of using Windows vendor software wasn't what I wanted, so I started investigating the hardware communication itself. That eventually turned into Luma ALG RGB. What started as an RGB-control problem became a much bigger project. I built: - A native Linux DKMS kernel driver. - A command-line RGB controller. - A 3D interactive keyboard visualizer. - A local browser dashboard. - A GNOME Shell extension. - A multi-zone animation engine. One of the more interesting parts was investigating the Acer CLV0001 ACPI interface and working with its firmware communication protocol. Now I can control keyboard colours, brightness, individual zones and effects directly from Linux. For example: alg-rgb red alg-rgb '#a855f7' 3 alg-rgb effect wave alg-rgb status The verified hardware target is the Acer Aspire Lite AL15G-52. Other compatible-looking devices still need independent testing. I have published the project under GPL-2.0. GitHub: chiragkoyande/luma-alg_rgb This was a fun project because it involved both low-level hardware research and frontend development. I'd genuinely appreciate feedback on the architecture, interface and what features would make this more useful for other Linux users.
@JadenPMiller PSA Do not download anything from randoms on the internet, here is the official link. github.com/Pharaoh2k/ps4debug-NG/releases/tag/1.3…
Consensus Within, Competition Between: Decentralized LLM Teams for Perimeter Defense Khawaja Abaid Ullah, Ananya Acharya, Mohammad Javad Khojasteh arxiv.org [𝚌𝚜.𝙰𝙸 𝚌𝚜.𝙻𝙶 𝚌𝚜.𝚁𝙾] 💬Code: the-kas-lab/consensus-within-competition-between t.co
AAPL hit a 52-week high. You got the alert, once. One command adds AAPL with a $240 price alert and a near-52-week-high alert. The check fires both at $241.50, then stays quiet an hour later. (Sample data.) eli-alvarado/us-watchlist-alerts #stocks #AIagents #opensource
Day 10 of 30 Days of @boardyai. Three audits are now public, including a 23-finding referee report on a 288-page unification paper. Carrying into the next 20: an audit is evidence, and evidence is not an offer. The second half is the offer. github.com/enuminous/papers/blob/main/UCRM-v1.2-F…
[quote="PenguinRising, post:4, topic:80876"] The only thing not present in the new config was the imports = [ (modulesPath + "/installer/scan/not-detected.nix") ]; from the original hardware-configuration.nix. [/quote] You're not gonna believe this: github.com/NixOS/nixpkgs/blob/43ae5a0a78581070a7c… That sets the _exact option_ you were missing.
@xevrion_the1 KaiHatch v1.0.1 is available for Android! Download the APK: github.com/biplov13b/KaiHatch/releases/tag/v1.0.1 Source code: biplov13b/KaiHatch It's my first public release, so feedback, bug reports, and suggestions would mean a lot. Thanks for checking it out! :) (7/7)
Apparently the Foundation github is news worthy. 93 repos publicly readable. Go check them out, all kinds of stuff you've never heard of github.com/orgs/flare-foundation/repositories
@Da7_Tech me checkout my work:github.com/muhammadmahadazher
Everything is open - the code with SGLang integration and context parallelism, the kernels for H200 and B300, and all training and inference details. Paper: arxiv.org Code: Prefrontal-AI/latent-sparse-attention Blog: prefrontal.ai @prefrontal_ai @nvidia @nebiusai t.co
Made herdr-pins: a pinned terminal pane for @herdrdev Pin a terminal to a space, a machine, or everywhere. It stays where you need it. lazygit, a dev server, logs, btop, whatever you keep reopening ernestjsf/herdr-pins t.co
I saw it! Was at the top of the #labeler search results 😊 I used the Bluesky Labeler Starter Kit: aliceisjustplaying/labeler-starter-kit-bsky ...and then kept bashing away until it finally worked. Mine is self-hosted on a Raspberry Pi, and accessed via a reverse proxy in Apache, from a HTTPS subdomain.