## SideX: A Lightweight VSCode Port SideX is an early-release, open-source project aiming to recreate Visual Studio Code’s functionality with a significantly smaller footprint. It achieves this by replacing Electron with Tauri – a Rust-based backend and native webview – resulting in faster performance and reduced resource usage (targeting 200MB RAM). The project is a heavily stripped, 1:1 architectural port of VSCode, utilizing over 5,600 TypeScript files adapted to run on a native shell. Core features like the Monaco editor, file explorer, integrated terminal, basic Git integration, and theme support are currently working, alongside extension loading from Open VSX. However, SideX is still under active development. Many workbench features are incomplete, extension compatibility is limited, and debugging/settings UIs are unstable. The developers are actively seeking community contributions to address bugs, implement features (especially terminal, extensions, and debugging), and improve platform support. If you're familiar with VSCode’s architecture, contributing is encouraged! You can find the project and contribution guidelines on GitHub: [https://github.com/Sidenai/sidex](https://github.com/Sidenai/sidex).

## Parlor: Real-Time, On-Device Multimodal AI Parlor is a research preview demonstrating real-time AI conversations using both voice and vision, all processed *locally* on your machine. It leverages Google’s Gemma 4 E2B for understanding audio and visual input, and Kokoro for text-to-speech output. Driven by the desire to create a sustainable, free English-learning tool, Parlor eliminates server costs by running entirely on-device – now achievable thanks to recent advancements in smaller, powerful AI models like Gemma. While not capable of complex agentic tasks, this represents a significant step towards accessible AI. Currently available for macOS (Apple Silicon) and Linux with a supported GPU, Parlor allows for hands-free, interruptible conversations. It’s easily runnable via a GitHub clone and requires approximately 3GB of RAM. The project aims for future portability to phones, envisioning a world where users can interact with AI by simply showing and speaking about objects in their environment, even utilizing multi-lingual support.

UsenetArchives.com is a historical archive of decades-old Usenet posts. **Users are warned that the content is unmoderated and may include adult, offensive, or objectionable material.** By accessing the site, you **confirm you are 18 years or older** (or the age of majority in your location) and understand the nature of the archive. You acknowledge full responsibility for your viewing choices and agree not to redistribute content illegally. The site contains user-generated content from public forums and cannot guarantee its appropriateness. Users can submit content removal requests, and access is governed by the site’s Privacy Policy. Essentially, proceed with caution and understanding of potentially sensitive material.

## Signals: A Deep Dive into Reactive Programming Signals are a modern approach to reactive programming, gaining traction in front-end frameworks like Solid, Vue, and others, but often lacking clear internal understanding. At their core, Signals manage state and automatically update dependent values when that state changes – like a spreadsheet where cells update based on formulas. This reactivity is powered by a “push-pull” algorithm. **Push-based Signals** notify subscribers when their value changes (without sharing the new state itself). **Pull-based “computed” values** are lazy; they only re-calculate when read *and* invalidated by a change in their dependencies. Crucially, computed values automatically track these dependencies without manual specification – a key advantage over traditional methods. This dependency tracking utilizes a global stack to link computations to the Signals they access. A cache system with a “dirty” flag ensures re-evaluation only happens when necessary, optimizing performance. The combination of push for invalidation and pull for re-evaluation creates a fine-grained, efficient reactivity system. Standardization efforts are underway to natively integrate Signals into JavaScript (TC39 proposal-signals), potentially offering a common foundation for future frameworks. This approach focuses on *how* changes propagate, offering a powerful alternative to existing state management solutions.

## Kokuyo Design Awards: Designs Rooted in Experience For nearly 25 years, the Kokuyo Design Awards have championed innovative stationery, transforming concepts into reality. This year’s theme, “hamon: design that resonates,” prompted designers to draw from personal experience to create impactful products. The Grand Prix winner, **“Before Note”** by Hiroki Kannari, reimagines the notebook as a customizable bundle of pages, empowering users to personalize their experience beyond mass production. Merit awards highlighted subtle yet impactful design: **“Gram”** by Takashi Higashide explored the effect of weight on writing, **“Notebooks Identified by Edges”** by Yuji Tsukamoto offered elegant organization with a sustainable touch, and **“Gradience Diary”** by Igarashi & Takizawa broke from rigid planner structures with a fluid, gradient-based layout. Other notable finalists included innovative packaging, pens encouraging reflection, and tools to enhance reading and capture inspiration, all demonstrating a focus on mindful interaction and personal connection.

## HarfBuzz GPU & Rendering Color Fonts with Slug Eric Lengyel’s Slug algorithm is now open-source and integrated into HarfBuzz as a GPU library, moving beyond text shaping into glyph rendering. Traditionally, text rendering relied on rasterizing bitmaps at specific sizes, problematic for scaling or 3D environments. Alternatives like Signed Distance Fields (SDFs) have limitations, but Slug calculates glyph coverage directly in the fragment shader, enabling perfect scaling and transformations. The core idea involves preprocessing glyph curves into a data buffer uploaded to the GPU. While initially for single-color glyphs, this can be extended to vector color fonts (like emojis) using formats like COLRv0 and COLRv1. COLRv0 renders emojis as stacked, colored glyphs, easily supported by adapting the existing single-color rendering. COLRv1 is more complex, utilizing a render tree with transforms, clipping, and blending – handled by HarfBuzz’s `hb-paint` component. This involves encoding drawing commands (clip masks, fills, transforms, groups) into a texture buffer and executing them in the fragment shader, potentially requiring a layer-based blending approach. Ultimately, this allows for crisp, scalable emoji rendering in any application, and offers advantages over traditional methods even for monochrome text. The author hopes this outline will inspire further development and integration into existing rendering libraries.

We’ve detected that JavaScript is disabled in this browser. Please enable JavaScript or switch to a supported browser to continue using x.com. You can see a list of supported browsers in our Help Center. Help Center Terms of Service Privacy Policy Cookie Policy Imprint Ads info © 2026 X Corp.

This document details the successful recovery of a severely corrupted 12TB Btrfs filesystem across a 3-device pool (data single, metadata DUP, DM-SMR disks) following a hard power cycle. Standard `btrfs check --repair` failed, entering an infinite loop due to issues within the extent and free space trees. Recovery was achieved using 14 custom C tools built against the btrfs-progs API, resulting in minimal data loss – approximately 7.2MB out of 4.59TB (0.00016%). The author shares this as a case study, *not* a bug report, offering constructive feedback for potential improvements to btrfs-progs. Nine specific areas for improvement are proposed, focusing on enhanced repair tool functionality (progress detection, extent tree rebuilding, orphan inode cleaning), clearer documentation, and fixes for identified edge cases. A reference implementation of the custom tools, along with a single patch, is publicly available on GitHub, offered as a resource for further investigation and discussion, not as direct patch submissions.

Bouncing signals off the Moon—known as Earth-Moon-Earth (EME) communication—has long been the ultimate challenge for radio amateurs. It required large antennas, expensive equipment, and accurate manual pointing and tracking. We try to bring this down to Earth, providing all the tools needed to experience the thrill of space communication, with an open source software-defined phased array.

## Bun vs. Node.js: A 5x Performance Boost for Trigger.dev Trigger.dev replaced Node.js with Bun in their latency-sensitive “Firestarter” service – a warm-start connection broker handling thousands of long-poll HTTP connections – resulting in a **5x throughput increase**. Initial profiling revealed bottlenecks in the Node.js implementation: slow SQLite queries, excessive Zod parsing, and inefficient header conversion. Phase 1 eliminated the SQLite database, replacing it with a composite-key Map for O(1) lookups, doubling throughput and halving latency. Phase 2 switched to Bun’s native `bun.serve()` API, further doubling performance. Subsequent profiling (Phase 3) identified and fixed hotspots related to Zod validation, header processing, and debug logging, improving CPU usage by 40%. Finally, compiling to a single binary (Phase 4) boosted throughput another 14% and reduced image size from 180MB to 68MB. A key discovery was a memory leak in Bun’s HTTP model: unresolved Promises from disconnected clients. Fixing this stabilized memory usage and further improved performance. The team emphasizes the importance of profiling, benchmarking at each step, and understanding Bun’s unique HTTP lifecycle. They also created a debugging skill for common Bun issues.

Recent research is shedding light on the clitoris, a historically understudied organ due to societal taboos and anatomical challenges. Utilizing advanced X-ray technology at a synchrotron, researchers have created detailed 3D images of clitoral nerves at a micron level – a first for this area of study. The research, published on bioRxiv, reveals the dorsal nerve of the clitoris (DNC) extends robustly into the clitoral glans, branching extensively and connecting to surrounding tissues like the mons pubis. This contradicts previous assumptions of the nerve tapering off. This detailed anatomical mapping has significant implications. It could improve reconstructive surgeries for those who have undergone female genital mutilation and help surgeons avoid nerve damage during other pelvic operations. Experts highlight a growing recognition of the importance of genital nerves, spurred by advancements in gender-affirming care, and emphasize the need for further research to develop better treatments for related medical conditions. The team plans to expand their study to include a more diverse range of donors.

👍 1 reacted with thumbs up emoji 👎 1 reacted with thumbs down emoji 😄 1 reacted with laugh emoji 🎉 1 reacted with hooray emoji 😕 1 reacted with confused emoji ❤️ 1 reacted with heart emoji 🚀 1 reacted with rocket emoji 👀 1 reacted with eyes emoji You can’t perform that action at this time.

/research "GraphQL performance characteristics" Gather evidence wheat reads your codebase, searches the web, and records what it finds. Each finding gets a type (factual, risk, estimate) and an evidence grade — from "stated" (someone said it) to "tested" (prototype-validated). r001 [factual|documented] GraphQL eliminates over-fetching for mobile clients, reducing payload size 40-60% r002 [factual|web] GraphQL N+1 query problem requires DataLoader or equivalent batching layer r003 [risk|documented] Existing REST caching (CDN, HTTP) does not transfer to GraphQL without custom solutions

## Software Versioning: Why It Matters & How to Do It Right A recent production incident highlighted a critical gap in software versioning: knowing *exactly* what code is running. Despite quickly identifying a potential fix, hours were wasted due to a lack of visibility into build versions and rollouts. This prompted a revisit to best practices, recalling a solution implemented over a decade ago in the i3 window manager. The core issue is surprisingly low versioning standards – even household appliances have detailed version information! Effective software versioning requires three steps: **Stamp it!** (include the source code revision), **Plumb it!** (ensure this information isn’t lost during builds and packaging), and **Report it!** (make the version visible in logs, UIs, and even HTTP headers). The most valuable piece of information is the VCS (Version Control System) revision. While Go now automatically stamps builds with this data, integrating it into packaging systems like Nix can be complex. Solutions like the `stapelberg/nix/go-vcs-stamping` overlay can bridge this gap. Ultimately, prioritizing “version observability” – consistently reporting the VCS revision throughout your system – is a high-impact, low-effort project that can save significant time and stress during incident response. Don't settle for basic version numbers; know *exactly* what code is running.

## Sheets: A Terminal Spreadsheet Sheets brings spreadsheet functionality to your terminal. You can launch it to directly read CSV data piped in via stdin, or open existing CSV files. Navigation is key-binding focused, allowing movement between cells with `h, j, k, l` and quick jumps to specific locations using commands like `gg` (top) or `B9` (cell B9). Sheets supports cell modification via direct assignment (`B7=10`) and editing in insert mode (`i`). Powerful features include search (`/`), marks (`ma`), jump lists (`ctrl+o`), and visual selection (`v`) for copying, cutting, and pasting. Formulas can be inserted in visual mode using `=`. Saving, opening other files, and quitting are done through a command prompt activated with `:`. Installation is simple with Go (`go install...`) or by downloading pre-built binaries. The project is MIT licensed and welcomes user feedback.

## Gemma Gem: Your On-Device AI Assistant Gemma Gem is a Chrome extension bringing a powerful AI assistant directly into your browser, powered by Google’s Gemma 4 model. It operates entirely on your machine – no internet connection or API keys needed – utilizing WebGPU for fast, private processing. Once installed (requiring a ~500MB download), Gemma Gem can read web pages, interact with elements (clicking buttons, filling forms), and even execute JavaScript. You access it via an icon in your browser and interact through a chat interface. The extension works through a system of content scripts, a service worker, and an offscreen document hosting the model. It offers tools like screenshot capture, text extraction, and page scrolling, all controllable through natural language. Users can customize the AI’s “thinking” process and manage settings like context clearing and site-specific disabling. Development and production builds are available, with detailed logging accessible through Chrome’s extension inspection tools.

Even the companies developing AI tools like Microsoft’s Copilot, OpenAI’s models, and xAI’s offerings are cautioning users against blindly trusting their outputs. Their terms of service explicitly state these AI are prone to errors and shouldn’t be relied upon for important decisions. Microsoft, currently promoting Copilot to businesses, initially included a disclaimer labeling the tool “for entertainment purposes only” and advising users to “use at your own risk.” They acknowledge this language is outdated and plan to update it. Similarly, OpenAI and xAI warn against treating their AI’s responses as definitive truth or factual information. These disclaimers highlight a crucial point: while AI is rapidly advancing, it’s still fallible and requires critical evaluation of its generated content – a sentiment echoed by both skeptics *and* the AI developers themselves.

## Modo: An Open-Source, Planning-First AI IDE Modo is a desktop IDE built on VS Code’s Void editor, designed to enhance AI-assisted coding by prioritizing *planning* before execution. Unlike typical “prompt-to-code” tools, Modo structures development through a defined workflow: **prompt → requirements → design → tasks → code.** Users define features or bug fixes within `.modo/specs`, creating markdown files for requirements, design, and implementation tasks. An AI agent then populates these, allowing for review and iterative refinement. Tasks are persistent and executable directly from the IDE with a single click. Key features include project steering via markdown rules, automated actions through JSON hooks, and parallel agent spawning for complex tasks. It supports multiple LLMs and integrates with tools like OpenAPI specs. A toggle allows switching between autonomous “Autopilot” and supervised modes. Modo is fully open-source (MIT license) and highly customizable, offering a dedicated theme, custom commands, and extensibility through installable “powers.” While currently community-maintained, it provides a robust foundation for developers seeking a more structured approach to AI-driven coding. [https://github.com/modoeditor/modo](https://github.com/modoeditor/modo)

## The Value of Portability in Open Source This piece argues against the increasingly hostile attitude towards software portability within the open-source community. The author pushes back against common arguments dismissing ports to “old” or less popular architectures (like Alpha, MIPS, PowerPC, or 32-bit systems), and those concerning endianness (big vs. little endian byte order). The author contends that supporting diverse architectures isn’t about clinging to the past, but recognizing active community interest and improving software quality. Ports can uncover hidden bugs – a security flaw was even found in the Linux kernel through testing on older hardware. Both big and little endian systems are valuable, and endian-safe code is simply *better* code. Similarly, 32-bit support remains relevant, particularly in resource-constrained environments, and can even boost efficiency on 64-bit systems. Ultimately, accepting community-driven ports demonstrates respect for users and fosters a more robust, well-tested codebase. The author champions a collaborative approach, urging maintainers to embrace contributions, even to unexpected platforms, as a sign of a thriving and valuable project.

v0.1.0-alpha APEX defines how AI agents communicate with brokers, exchanges, dealers, and other execution venues. One protocol. Realtime state. Autonomous safety. Multi-asset by design. FIX Protocol connected electronic trading. APEX connects agentic trading.

## mdarena: Evaluate the Impact of Your CLAUDE.md Files **mdarena** is a tool to benchmark the effectiveness of your `CLAUDE.md` files – the instructions you provide to agents like Claude – against your codebase’s actual PRs. Research suggests these files often *decrease* agent success and increase costs. **How it works:** 1. **`mdarena mine`**: Extracts merged PRs to create a task set, automatically detecting test commands from your CI/CD configuration. 2. **`mdarena run`**: Tests different `CLAUDE.md` configurations (or no context) by applying them to pre-PR commits and evaluating the resulting agent-generated patches. It can run your existing tests (like SWE-bench) or fall back to diff overlap scoring. 3. **`mdarena report`**: Compares agent patches to the original PR diffs, measuring test pass/fail rates, code overlap, cost, and statistical significance. **Key Findings from a production monorepo test:** Per-directory `CLAUDE.md` files offering targeted context significantly improved test resolution (~27%) compared to a baseline without them, and outperformed a consolidated, single-file approach. **mdarena prioritizes security** with isolated checkouts preventing access to future commits. It supports SWE-bench tasks and requires Python 3.11+, `gh`, and `claude` CLIs.

## Local Multimodal Memory: Find Anything with a Search This tool lets you create a local, searchable database of your files – images, audio, video, PDFs, and text – using natural language. Simply embed your files, and then *find* them using descriptive queries, even without any existing metadata or tagging. For example, searching "team dinner" will surface relevant photos! It’s powered by Gemini Embedding 2 (free tier) and ChromaDB, storing everything locally on your machine for privacy. Setup is streamlined with an animated wizard, and a Raycast extension provides instant visual search with thumbnails. **Key Features:** * **Cross-modal search:** Works seamlessly across all file types. * **Local & Private:** Data stays on your machine. * **Easy Setup:** Animated wizard guides you through the process. * **Raycast Integration:** Quick visual search from your launcher. **Get Started:** [https://github.com/hughminhphan/vector-embedded-finder](https://github.com/hughminhphan/vector-embedded-finder)

## GuppyLM: A Tiny, Trainable Language Model GuppyLM is a 9 million parameter language model designed to demonstrate that building your own LLM doesn’t require extensive resources. Created with a single Colab notebook and minimal training time (around 5 minutes), it showcases the inner workings of language models – from data to output – making them less of a “black box.” The model embodies a small fish named Guppy, communicating in short, lowercase sentences focused on its aquatic world: water, food, and tank life. It intentionally lacks understanding of complex human concepts. GuppyLM is trained on 60,000 synthetic conversations covering 60 topics, utilizing a simple vanilla transformer architecture. The project prioritizes simplicity, foregoing advanced techniques like GQA or RoPE to maintain clarity and efficiency at a small scale. The code and pre-trained model are publicly available on HuggingFace, allowing anyone to experiment and chat with Guppy directly. It’s a practical example proving LLM creation is accessible, even without a PhD or massive computing power.

Please enable JS and disable any ad blocker

## Beyond Filesystems: Improving AI Coding with Semantic Addressing Historically, code organization has relied on filesystems, mirroring human-understandable hierarchies. However, this forces AI coding agents to operate at a low, “operational” level, requiring extensive tooling (like IDEs) to manage code based on *where* it’s stored, not *what* it does. To improve AI efficiency, Sumato AI proposes shifting focus to **narrative hygiene** – crafting clear, direct “stories” for AI agents. This is achieved through two key innovations: **Spath** and **Splan**. **Spath** is a semantic addressing format allowing agents to identify code symbols *without* referencing files or line numbers. **Splan** defines a grammar for expressing *actions* on those symbols – complete intentions like “replace this function with this new version” – also without filesystem dependencies. By operating on semantic meaning, rather than file paths, Spath & Splan reduce wasted processing, improve AI “cognitive quality,” and enable transactional code changes (all succeed or none do). Both are designed as open, adaptable grammars with language-specific “dialects.” Sumato AI is open-sourcing these tools, believing a shift towards semantic abstraction will unlock significant advancements in AI-assisted coding.

Investor interest is rapidly shifting from OpenAI to its competitor, Anthropic, causing OpenAI shares to become difficult to sell on the secondary market. While investors are seeking to offload around $600 million in OpenAI stock, demand is weak, contrasting sharply with the $2 billion ready to invest in Anthropic. This shift is driven by perceived better risk-reward with Anthropic, whose $380 billion valuation lags OpenAI’s $852 billion, suggesting greater potential for growth. Anthropic is also gaining traction in the lucrative enterprise market, while concerns grow over OpenAI’s high operating costs and slower enterprise adoption. Despite OpenAI completing a massive $122 billion fundraising round, secondary market activity tells a different story. Banks are even waiving fees for OpenAI shares, while maintaining them for Anthropic, signaling confidence in the latter. Though both companies face challenges – Anthropic with legal disputes and security breaches – investor appetite currently favors Anthropic’s trajectory.

## Halter: Virtual Fencing for a Billion Cattle Founders Fund recently led a $220 million investment in Halter, a New Zealand startup revolutionizing cattle management. Halter’s system utilizes solar-powered smart collars, a network of towers, and a smartphone app to create “virtual fences,” allowing farmers to remotely manage herds and optimize grazing patterns. Founded by Craig Piggott, Halter addresses the challenge of managing cattle across vast, remote landscapes without traditional methods like dogs or vehicles. The collars use audio and vibration cues to train cattle, while simultaneously collecting behavioral data to monitor animal health and fertility – creating the world’s largest cattle behavior dataset. Farmers see a potential 20% increase in land productivity by optimizing grazing, translating to significant financial returns. While competitors like Merck’s Vence and drone-based systems exist, Halter emphasizes reliability and proven results, honed over nine years in New Zealand. Currently operating in New Zealand, Australia, and 22 US states, Halter aims to expand globally, targeting a market of one billion cattle with its current penetration at just one million. The company’s focus on demonstrable ROI is key to its success in a traditionally slow-to-adopt agricultural tech sector.

Improve your search results with advanced search prefixes. Search with YouTube Google Video Search Playlist 0 videos selected No results found Try adjusting your search terms or filters © 2026 Playlists.at · Cookie & Privacy Policy · Imprint

## Termhub: AI-Powered Terminal Control Termhub is an AI-native tool designed to streamline interaction with terminal sessions. It enables AI to intelligently manage terminals – opening windows/tabs, launching sessions, sending commands, and capturing only the *new* output. This "send-to-capture delta loop" is key for efficient AI workflows. **Key Features:** * **AI-Driven Automation:** Automates terminal tasks based on AI inspection and needs. * **Cross-Platform:** Supports macOS (iTerm2, Terminal) and Windows (Windows Terminal, CMD). * **SDK Available:** Offers a JavaScript SDK for programmatic control of terminals. * **Core Commands:** Includes `open`, `list`, `resolve/find`, `send`, `press`, `capture`, `focus`, `close`, `doctor`, and `spec`. * **Session Management:** Uses session IDs or handles for precise targeting. * **Delta Capture:** Captures only output *after* a command is sent, improving efficiency. **Installation:** Available via npm (`@duo121/termhub`), Homebrew (macOS), or direct download from GitHub Releases. Termhub simplifies integrating terminal interactions into AI applications, offering a robust and flexible solution for automated tasks.

We’ve detected that JavaScript is disabled in this browser. Please enable JavaScript or switch to a supported browser to continue using x.com. You can see a list of supported browsers in our Help Center. Help Center Terms of Service Privacy Policy Cookie Policy Imprint Ads info © 2026 X Corp.