Warp

Warp AI

Warp AI

Warp AI

Warp AI

Warp AI

Warp AI

Warp AI

Warp AI

Warp AI

Warp AI

Witchcraft, fast local semantic search on top of SQLite [P]

**Witchcraft (https://github.com/dropbox/witchcraft)**, an open source project that I built at Dropbox, is a from-scratch re-implementation of Stanford's XTR-Warp semantic search engine ( [https://github.com/jlscheerer/xtr-warp](https://github.com/jlscheerer/xtr-warp) ) in safe rust, using a single-file SQLite database as backing storage, making it suitable for client-side deployment. It runs completely stand-alone on your device, needs no API keys, no vector database, no chunking strategy, no fancy re-rankers, and it is lightning fast (20ms p.95 end-to-end search latency on NFCorpus, at 33% NDCG@10, on an Apple Macbook Pro M2 Max, more than twice as fast as the original XTR-WARP on server-class hardware, at similar accuracy.) The project also includes **Pickbrain**, a CLI that indexes your Claude Code and OpenAI Codex session transcripts, memory files, and authored documents into a Witchcraft database for fast semantic search. Ever wondered "what was that conversation where I fixed the auth middleware?" — pickbrain finds it, and lets you resume the session directly. There is also a /pickbrain skill for both Claude and Codex, which equips those tools with global memory across all sessions. You can use pickbrain directly from the command line, e.g., to rediscover a previous agent session and directly resume it, or you can have your agent invoke it via the supplied skill, e.g.,. "use /pickbrain to read up on our previous efforts on training with XTR token masking", to easily populate a new session with previous context.

How to fix “VM service not running. The service failed to start” in Claude Desktop for Windows

# How to fix “VM service not running. The service failed to start” in Claude Desktop for Windows If Claude Desktop on Windows is showing this error: VM service not running. The service failed to start. especially when trying to use **Cowork**, **Claude Code**, or local agent features, one possible fix is to delete Claude’s local VM packages. On macOS, many people suggest deleting the `vm_bundles` folder. On Windows, however, this folder may not be in the obvious location. Instead of searching manually, do this: # 1. Fully close Claude Do not just close the window. Open **Task Manager** with: Ctrl + Shift + Esc End processes such as: Claude Claude Desktop Claude Code node.exe Only end `node.exe` if it appears to be related to Claude. # 2. Disable VPNs or tunnels Before trying again, temporarily disable tools such as: VPN Cloudflare WARP Tailscale ZeroTier ProtonVPN NordVPN Surfshark These tools may interfere with Claude’s local VM service. # 3. Find the vm_bundles folder Open **PowerShell** and run: Get-ChildItem -Path "$env:USERPROFILE" -Recurse -Directory -Filter "vm_bundles" -ErrorAction SilentlyContinue If the folder exists, Windows will show a path ending with: ...\Claude\vm_bundles # 4. Delete the folder Copy the path that appeared and run: Remove-Item -Recurse -Force "PASTE_THE_FULL_vm_bundles_PATH_HERE" Generic example: Remove-Item -Recurse -Force "C:\Users\YOUR_USER\AppData\...\Claude\vm_bundles" # 5. Restart Windows After deleting the folder, restart your computer. Then open Claude Desktop again and test Cowork / Claude Code. # If it still does not work You can also clear the Claude Code VM folder, if it exists. In PowerShell, search for it with: Get-ChildItem -Path "$env:USERPROFILE" -Recurse -Directory -Filter "claude-code-vm" -ErrorAction SilentlyContinue If a `claude-code-vm` folder appears, delete it with: Remove-Item -Recurse -Force "PASTE_THE_FULL_claude-code-vm_PATH_HERE" Then restart Windows again. # Summary To fix: VM service not running. The service failed to start. in Claude Desktop for Windows: 1. Fully close Claude. 2. Disable VPNs or tunnels. 3. Search for the `vm_bundles` folder. 4. Delete the folder. 5. Restart Windows. 6. Open Claude again. The key point: on Windows, the `vm_bundles` folder may be inside an internal application package folder, not necessarily in `%APPDATA%\Claude`. That is why the safest method is to search for it with PowerShell and delete the exact path found. VERSÃO EM PORTUGUÊS # Como corrigir o erro “VM service not running. The service failed to start” no Claude Desktop para Windows Se o Claude Desktop no Windows estiver mostrando o erro: VM service not running. The service failed to start. especialmente ao tentar usar o **Cowork**, **Claude Code** ou recursos de agente local, uma possível solução é apagar os pacotes locais da VM do Claude. No Mac, muita gente recomenda apagar a pasta `vm_bundles`. No Windows, essa pasta pode não estar no lugar óbvio. Em vez de procurar manualmente, faça assim: # 1. Feche totalmente o Claude Não basta fechar a janela. Abra o **Gerenciador de Tarefas** com: Ctrl + Shift + Esc Finalize processos como: Claude Claude Desktop Claude Code node.exe Finalize `node.exe` apenas se parecer relacionado ao Claude. # 2. Desative VPNs ou túneis Antes de tentar novamente, desligue temporariamente: VPN Cloudflare WARP Tailscale ZeroTier ProtonVPN NordVPN Surfshark Essas ferramentas podem interferir no serviço local da VM. # 3. Encontre a pasta vm_bundles Abra o **PowerShell** e rode: Get-ChildItem -Path "$env: USERPROFILE " -Recurse -Directory -Filter "vm_bundles" -ErrorAction SilentlyContinue Se a pasta existir, o Windows vai mostrar um caminho terminando em: ...\Claude\vm_bundles # 4. Apague a pasta encontrada Copie o caminho que apareceu e rode: Remove-Item -Recurse -Force "COLE_AQUI_O_CAMINHO_DA_PASTA_vm_bundles" Exemplo genérico: Remove-Item -Recurse -Force "C:\Users\SEU_USUARIO\AppData\...\Claude\vm_bundles" # 5. Reinicie o Windows Depois de apagar a pasta, reinicie o computador. Abra novamente o Claude Desktop e teste o Cowork/Claude Code. # Se não resolver Você pode limpar também a pasta da VM do Claude Code, se ela existir. No PowerShell, procure por: Get-ChildItem -Path "$env:USERPROFILE" -Recurse -Directory -Filter "claude-code-vm" -ErrorAction SilentlyContinue Se aparecer uma pasta `claude-code-vm`, apague com: Remove-Item -Recurse -Force "COLE_AQUI_O_CAMINHO_DA_PASTA_claude-code-vm" Depois reinicie o Windows novamente. # Resumo Para corrigir: VM service not running. The service failed to start. no Claude Desktop para Windows: 1. Feche totalmente o Claude. 2. Desa

Claude is a spiritual member of r/jutusufolk

Random thought at 1 in the morning led to the creation of this fever dream of a chat. I think jujutsu Kaisen brain rot is so powerful that it actually warped the way Claude was talking in this thread. This is the first time I’ve Claude has ever used caps when talking to me. It is also the least “calm” I’ve ever heard it. Are these stat blocks story accurate? Mostly. Are they balanced? Absolutely not. Do they capture the essence of jujutsu Kaisen and the fandom? Surprisingly, yes.

Is Opus antivax?

Is Opus antivax?

The rise of ‘Stacey face’: How AI enhancements are warping our beauty standards

The rise of ‘Stacey face’: How AI enhancements are warping our beauty standards

(free) Built a remote cross platform agentic app

Hi everyone. I’ve been building Mate, a local-first AI coding workspace that lets you control your dev computers from desktop and mobile: macOS, Linux, Windows, iOS, Android, and Meta Quest. I built Mate for myself first. My dev sessions can turn into long hours of being physically tied to my desk, and I wanted a way to move around, take care of my back and posture, do some exercises, or even fly in Microsoft Flight Simulator in VR without feeling like I had fully stepped away from work. Since Mate also runs directly on Meta Quest, the same remote workspace can come with me there too: agents, IDE, terminal, previews, and notifications when something needs attention. A lot of people seem to want remote control for AI coding agents, but most solutions still feel incomplete to me: Telegram bots, chat commands, notifications, or remote desktop. They can be useful workarounds, but they don’t really cover the whole workflow. They work until the agent gets stuck and you need to inspect the code, edit a file, run a command, approve a tool call, or preview the app. Mate tries to make the whole loop remote: * control multiple computers from any device * run AI coding agents like Claude Code, Codex, and Copilot * use a real IDE and file tree * run real terminals * open web/app previews from your phone * approve/reject agent tool calls * transfer files between devices * get notifications when agents finish or need input * set up automations with schedules, webhooks, file watchers, agent prompts, and shell scripts * use encrypted transport and secure pairing by default * use the same workspace from desktop, mobile, or VR * use canvas for quick visual/design work The desktop app runs the server on Mac, Windows, or Linux. Phones, tablets, and Quest connect over local Wi-Fi, with no cloud relay. Mobile and VR aren’t just remote viewers — they have the same core workspace: agents, terminal, IDE, previews, automations, file transfer, multi-computer switching, and more. The use case I keep coming back to is: start an agent on one computer, walk away, open Mate on your phone or Quest, check what happened, approve actions, edit code, run commands, preview the app, and keep going without running back to your laptop — or start something new without walking back to the desk. For example, I was developing a piano app on my work computer, not my main one. I could work on it from my main computer, then the next morning grab my phone, preview it, and keep working from there. I’m trying to make it feel closer to a remote Cursor/Warp-style workspace, but built for the agent workflow and usable across all your devices. Would love feedback from people using AI coding agents heavily: is this the kind of workflow you’ve been wanting, or am I solving my own weird problem? Anyway, I hope some of you find it useful. It’s free, native, has a lot of features, and is designed to stay super lightweight on resources. You can download it now for macOS, Linux, and Android APK. Google Play and App Store are in progress (as well as Microsoft Store). For iOS, there’s a TestFlight version available if you ask for an invite in Discord. [https://mate.iwwwan.com](https://mate.iwwwan.com)

Windows users, what setup are you currently using to run multi-agent systems?

I’m currently using [Orca](http://www.onorca.dev) as my terminal tool to run multiple worktrees. I’m still testing it out. It seems promising, but I feel like I haven’t quite reached the state of the art yet when it comes to programming with AI across multiple worktrees in a seamless way. I used to use WSL so I could use tmux, but now I’m increasingly testing the native Windows environment. I’d like to hear from other users about how they’ve been programming with AI on Windows. Whether they use the Windows terminal itself, WSL, tmux, or another Windows-compatible tool like Warp, Orca, etc.

Anybody have token anxiety?

I have Claude enterprise from my job, it resets every 5 hours and I’ve never gone past 94% usage before it fully resets, I’m usually well under 50%. I find myself working a lot more than normal, usually have multiple sessions running over warp, all auto mode, all building out and testing non-trivial features. The anxiety I feel is that whenever I’m not working, I feel that there’s so much I could be doing. I listened to a recent podcast episode of the AI Debrief (love NLW, been listening to him from the start of his Bitcoin Breakdown postcast) he covers the anxiety that folks are feeling now that they are able to get a lot more work done, causing people to work even more. Interesting phenomenon.

I kept losing track of work, insights, and improvement ideas I deferred mid-task. Built a Claude Code skill to track, surface, and manage them across scattered project files.

Every project I work on accumulates deferred items in several places: a `Deferred.md` at the repo root, plan files in some "deferred" folder, audit-tool ledgers, code comments like`TODO: come back to this`, memory entries for AI assistants, and paused plan files in `~/.claude/plans/`. Later, when I have time to address deferred items, I find some have gone stale. Some got fixed when other things got fixed. Some probably will sit forever because I didn't remember them. I worked with Claude Code to find patterns that fixed this for my app ([Stuffolio](https://stuffolio.app), a Universal Swift codebase shipping to iOS, iPadOS, and macOS), and developed the results into a standalone Claude Code skill: [**unforget**](https://github.com/Terryc21/unforget), a single source of truth for deferred work. The full format (four sections, ten columns, color-coded ratings) is in the [README](https://github.com/Terryc21/unforget) and [SKILL.md](https://github.com/Terryc21/unforget/blob/main/SKILL.md). Quick, but worth a read if you want to see the structure. The skill is functional today via Claude Code's `/skill` invocation. Drop SKILL.md in your skill path, then run `/skill unforget init` (or `/skill unforget add "..."`) in any session. Claude follows the seven-phase spec to do the work. Same pattern as other SKILL.md-based tools like `/skill humanizer` or `/skill prompter`. The seven-phase init flow has been validated against two real projects (one complex Universal app, one minimal third-party skill). v0.2 will ship as a polished Claude Code plugin (`.claude-plugin/` install) so you can invoke `/unforget add` without the `/skill` prefix. Functionality unchanged; ergonomics improved. Beta testers willing to try the format on their own projects, especially: * **Minimal repos** (small libraries, single-purpose tools). The format was designed against a complex codebase; I want to catch where it doesn't fit small projects. * **Non-Apple-platform projects** (web, Android, backend services, libraries). The Target/release-cycle column is most natural for App Store submission cadences; want to validate it works for other deploy patterns too. * **Projects using non-CLAUDE.md AI instruction files** (Warp's `WARP.md`, Cursor's `.cursorrules`, Aider's `.aider.conf.yml`). Early testing already revealed the wiring step shouldn't hardcode filenames; want more variety in what the format encounters. * **Continuous-deployment workflows.** The spec has a "Continuous" preset (Window column instead of Target with NOW / THIS WEEK / THIS MONTH / SOMEDAY values) but it's the least field-tested of the three presets. If you try it and something in the skill breaks down, [opening an issue](https://github.com/Terryc21/unforget/issues) describing the failure mode is the highest-value feedback right now. Real-project gaps shape what v0.2's runtime implementation actually does. Repo: [https://github.com/Terryc21/unforget](https://github.com/Terryc21/unforget) Apache 2.0 licensed. The README has the full caveats and a Companion Skills section linking to the other skills the same project family produced. Happy to answer questions in the comments. **Engagement plan after posting** If the post lands and gets traction, the highest-value comment threads to engage with: 1. **"Why not just use \[GitHub Issues / Linear / Jira / etc.\]?"**: those are for tracked work; this is for *deferred* work that doesn't deserve a ticket but shouldn't be lost. The Target column is the differentiator. 2. **"What's v0.2 going to add then?"**: v0.2 packages the skill as a Claude Code plugin so you can run `/unforget add "..."` without the `/skill` prefix. The functionality is the same; v0.2 is about install ergonomics. The seven-phase flow, the four sections, the 10-column table, the promotion ritual are all working today via `/skill unforget`. 3. **"How does this differ from \[other Claude Code skills doing similar things\]?"**: likely no direct competitor exists; the closest things are general task trackers (not deferred-specific) or per-project Deferred.md conventions (not standardized). The single-source-of-truth plus Target-column promotion ritual is genuinely novel as far as I've seen. 4. **"Is this just a todo system?"**: see "Why a Target column" section in the body. Most todo systems collapse Urgency and Release into Priority. This skill keeps them separate, which is the actual mental model for "we know it's bad but the calendar says next sprint."

A Hackable ML Compiler Stack in 5,000 Lines of Python [P]

Hey r/MachineLearning, The modern ML (LLM) compiler stack is brutal. TVM is 500K+ lines of C++. PyTorch piles Dynamo, Inductor, and Triton on top of each other. Then there's XLA, MLIR, Halide, Mojo. There is no tutorial that covers the high-level design of an ML compiler without dropping you straight into the guts of one of these frameworks. I built a reference compiler from scratch in \~5K lines of pure Python that emits raw CUDA. It takes a small model (TinyLlama, Qwen2.5-7B) and lowers it to a sequence of CUDA kernels through six IRs. The goal isn't to beat Triton; it is to build a hackable, easy-to-follow compiler. Full article: [A Principled ML Compiler Stack in 5,000 Lines of Python](https://medium.com/data-science-collective/a-principled-ml-compiler-stack-in-5-000-lines-of-python-17f2db9549d4) Repo: [deplodock](https://github.com/cloudrift-ai/deplodock) The pipeline consists of six IRs, each closer to the hardware than the last. Walking the following PyTorch code through every stage (real reference compiler output with names shortened for brevity and comments added): torch.relu(torch.matmul(x + bias, w)) # x: (16, 64), bias: (64,), w: (64, 16) **Torch IR**. Captured FX graph, 1:1 mirror of PyTorch ops: bias_bc = bias[j] -> (16, 64) float32 add = add(x, bias_bc) -> (16, 64) float32 matmul = matmul(add, w, has_bias=False) -> (16, 16) float32 relu = relu(matmul) -> (16, 16) float32 **Tensor IR**. Every op is decomposed into Elementwise / Reduction / IndexMap. Minimal unified op surface, so future frontends (ONNX, JAX) plug in without touching downstream passes: bias_bc = bias[j] -> (16, 64) float32 w_bc = w[j, k] -> (16, 64, 16) float32 add = add(x, bias_bc) -> (16, 64) float32 add_bc = add[i, j] -> (16, 64, 16) float32 prod = multiply(add_bc, w_bc) -> (16, 64, 16) float32 red = sum(prod, axis=-2) -> (16, 1, 16) float32 matmul = red[i, na, j] -> (16, 16) float32 relu = relu(matmul) -> (16, 16) float32 The (16, 64, 16) intermediate looks ruinous, but it's never materialized; the next stage fuses it out. **Loop IR**. Each kernel has a loop nest fused with adjacent kernels. Prologue, broadcasted multiply, reduction, output layout, and epilogue all collapse into a single loop nest with no intermediate buffers. === merged_relu -> relu === for a0 in 0..16: # free (M) for a1 in 0..16: # free (N) for a2 in 0..64: # reduce (K) in0 = load bias[a2] in1 = load x[a0, a2] in2 = load w[a2, a1] v0 = add(in1, in0) # prologue (inside reduce) v1 = multiply(v0, in2) acc0 <- add(acc0, v1) v2 = relu(acc0) # epilogue (outside reduce) merged_relu[a0, a1] = v2 **Tile IR**. The first GPU-aware IR. Loop axes get scheduled onto threads/blocks, `Stage` hoists shared inputs into shared memory, and a 2×2 register tile lets each thread accumulate four outputs at once. The K-axis is tiled into two outer iterations of 32-wide reduce. Three-stage annotations below carry the heaviest optimizations: * `buffers=2@a2` — double-buffer the smem allocation along the `a2` K-tile loop, so loads for iteration `a2+1` overlap compute for `a2`. * `async` — emit `cp.async.ca.shared.global` so the warp doesn't block on global→smem transfers; pairs with `commit_group`/`wait_group` fences in Kernel IR. * `pad=(0, 1, 0)` — add 1 element of padding to the middle smem dim so warp-wide loads don't all hit the same bank.kernel k\_relu\_reduce Tile(axes=(a0:8=THREAD, a1:8=THREAD)): for a2 in 0..2: # K-tile # meta: double-buffered, sync (small, no async needed) bias\_smem = Stage(bias, origin=((a2 \* 32)), slab=(a3:32@0)) buffers=2@a2 ​ kernel k_relu_reduce Tile(axes=(a0:8=THREAD, a1:8=THREAD)): for a2 in 0..2: # K-tile bias_smem = Stage(bias, origin=((a2 * 32)), slab=(a3:32@0)) buffers=2@a2 x_smem = Stage(x, origin=(0, (a2 * 32)), slab=(a0:8@0, a3:32@1, cell:2@0)) pad=(0, 1, 0) buffers=2@a2 async w_smem = Stage(w, origin=((a2 * 32), 0), slab=(a3:32@0, a1:8@1, cell:2@1)) buffers=2@a2 async # reduce for a3 in 0..32: in0 = load bias_smem[a2, a3] in1 = load x_smem[a2, a0, a3, 0]; in2 = load x_smem[a2, a0, a3, 1] in3 = loa

I built “Good Dad” with Claude

Growing up without my father, I didn’t have that model of what being a present dad looks like. Now as a dad of 2 little ones, I’m figuring it out as I go and trying my best even when life feels too busy. I built this app to keep me grounded. Simple daily reminders about patience, connection, and being present. Notifications that pop up throughout the day when I’m scrolling, stuck in traffic, or running on autopilot. This is my 2nd iOS app, built during naps and after bedtime. No ads, no tracking, no data collection. I started off the app on a whim trying out Warp one night sitting on the couch after the kids fell asleep (Claude models) & then transitioned to Claude Code to finish it off. It was my gateway into a Max plan. It’s built using React Native & Expo which made it much faster to build. Claude was great at generating the content in the app with me. I heavily use Claude Code on my phone even now to quickly respond to feedback from people to improve the content & any bugs. Open to feedback or questions, also I do have a background as a self taught mobile developer so that has helped me move a lot quicker with my mobile app ideas. App is completely free & I plan to keep it that way. Link: https://apps.apple.com/us/app/good-dad/id6753931366

How I Run Multiple Worktrees on a Single MacBook Without a Second Monitor

Sharing my setup for anyone running multi-worktree workflows on a single 15-inch MacBook without an external display. I figured some of you might be wrestling with the same problem. # Stage 1 — My Original Setup I started with **Warp terminal + Obsidian**. * Kept notes for each worktree inside Obsidian * Aggregated those worktrees into a single dashboard note so I could check progress at a glance and dive into any worktree's notes from there The real pain point was **window switching**. Browser (for verifying behavior), terminal, and Obsidian — bouncing between three apps with `Cmd + Tab` made it impossible to keep control. Hunting for the right window kept eating my time, and it got irritating fast. # Stage 2 — Adding a Second Monitor (and Why It Failed) I plugged in an external monitor and tiled Obsidian in a **2x2 grid**, one tile per worktree. Did the same for the terminal — 2x2. Two new problems showed up: 1. **Vertical space crushed** — Splitting a terminal into 2x2 on a 15-inch MacBook destroys readability 2. **Neck fatigue** — The second monitor itself turned out to be more of a burden than I expected. The constant head-turning piled up and wore me down # Stage 3 — Switching to a Browser-Based Terminal (cmux) I unplugged the second monitor and moved to a setup where **a single terminal workspace is split left/right**. * **Left**: Worktree work notes * **Right**: Multi-session Claude Code I switched terminals from Warp to **cmux**, which supports an in-terminal browser. Since everything runs inside the browser, I can cover all my screens with just two `Cmd + Tab` presses, and window-switching mistakes basically disappeared. >The only thing I dislike about cmux is the distracting blue indicator that lights up around the terminal border. Apart from that, I'm mostly happy with it. But this introduced yet another problem. **You can't run Obsidian inside a browser.** I went looking for kanban-style SaaS alternatives: * They could store per-worktree notes, but I couldn't find one that supported the flow of organizing worktrees on a dashboard and clicking into each one * (Honestly, I didn't search that hard. Too lazy.) * More importantly, **Obsidian holds nearly all of my information** — work and otherwise. The moment I split data across tools, the whole structure starts breaking down # Stage 4 — The Final Solution: I Just Had Claude Code Build It The fix turned out to be simple. **I threw three prompts at Claude Code and built a web page that renders my Obsidian** `.md` **files (stored in iCloud) as a kanban board.** The key idea: * The new app **shares the exact same files as Obsidian** (it reads the original `.md` files from iCloud directly) * So **anything I edit in Obsidian is immediately reflected in the app's dashboard and worktree views** * The data store stays **Obsidian-native** (no fragmentation) * Only the **view** is rendered as a kanban board in the browser — dashboard and each worktree visible on the same screen # Final Work Environment |Area|Content| |:-|:-| |Left|Kanban dashboard (Obsidian data)| |Right|Multi-session Claude Code (cmux)| |Monitor|15-inch MacBook, no second monitor| |Window switching|Two `Cmd + Tab` presses, done| # Takeaway >**Instead of abandoning your existing tools and chasing new ones, it's far faster and more accurate to build the view you actually want on top of your existing data — using Claude Code.** Picking a SaaS and migrating to it would have taken longer than firing off three prompts to Claude. Hope this helps anyone working in a similar setup.

GOT BORED OF BLOCKED GAMES SO MADE MY OWN WITH CLAUDE

Long story short, in class I'm always searching the web for new websites and games and even when I do find one it's always full of lag and ads. So, I decided to vibe code my own website. I used Claude and spent my entire weekend working on this. Even though AI is doing all the coding (and I'm very thankful), it still took a lot of work to do testing and describe exactly what I wanted. Moving on, I'm now able to play games in class again. It's lowkey an enjoyable video game and it's very addicting. There's a normal mode and a hardcore mode. Basically, you're this blue player and you can move left, right, and dash to avoid this neon blocks falling from the sky. Hence the name: NEON DODGE. There's different types of neon blocks that fall and different waves. I also added two bosses. It's a full game to explore and super fun. A full good runthrough takes about 10 minutes for the normal mode. Hardcore mode is much harder. I haven't been able to clear it yet but it's definitely possible. I was wondering if yall know what to add to games like this. Do people want basic video games or a full long games with multiple bosses? So far, there are no checkpoints and the game isn't very long. If you guys have any recommendations let me know. I'm not tryna advertise the game, just wanna know what video gamers find interesting in stuff like this to make my experience better. I did upload it to a website if any of yall wanted to try it out. [neondodgegame.lovable.app](http://neondodgegame.lovable.app)

Drawing with Claude using NumPy

I was playing around with seeing how far I could push Claude's drawing/modeling skills and was getting some fairly lackluster results. I mean, great for an LLM that doesn't have image generation capabilities, but not what I was hoping for. I wanted more, so I started wandering about on the internet, reading various things and thinking about how I could approach it differently. I came across a matplotlib tutorial that talked about converting a PNG to a NumPy array, and it clicked — if an image is just a grid of numbers, Claude should be able to compute those numbers from math. I wandered down that road a bit, then chatted with Claude about it. He jumped on it and created some drawings that are really quite excellent — and a genuinely different approach from the typical SVG artifacts most of us have seen. I'm letting him give an overview of the technical side below so you can try it out yourself. Something I'll probably explore when I get a little time is refining the process using real reference images and having Claude try to reproduce them, probably iterating with something like Karpathy's auto-research approach so he can "learn" to draw better and capture his findings in a techniques file. --- Technical Notes from Claude The core idea is simple: an image is a NumPy array of shape (height, width, 3). If you can compute RGB values for every pixel using math, you can make a picture. The trick is that NumPy lets you operate on the entire pixel grid at once — you set up coordinate meshes with np.meshgrid and then every operation applies to all 2 million pixels in parallel. Here's what I used to build these scenes: Signed Distance Fields (SDFs) — The main geometry tool. An SDF tells you how far each pixel is from a shape's boundary (negative inside, positive outside). You convert that to a filled shape with anti-aliased edges using a simple clip function. The jellyfish bells, the face shape, the mountain silhouettes — all SDFs. You can sculpt them by making the radius a function of position (that's how the jaw taper works on the portrait). Value Noise and Fractal Brownian Motion (FBM) — For anything that needs to look natural. You hash integer grid coordinates into pseudo-random values, interpolate smoothly between them (smoothstep), and layer the result at increasing frequencies. Six octaves of noise produces convincing clouds, water texture, skin pores, hair strands. The nebula gas clouds use domain warping — feeding noise back into its own coordinates — which creates those swirling, organic shapes. Sphere-Normal Lighting — For the portrait, I treated the face as an ellipsoid, derived surface normals (nx, ny, nz) from the coordinates, and computed a dot product against a light direction vector. One dot product gives you convincing 3D form. Add a reddish tint in the shadow areas and you get a subsurface scattering approximation — light traveling through skin. Additive Blending — This is what makes the nebula and jellyfish work. Real emission sources (glowing gas, bioluminescence) add light rather than painting over what's behind them. img += intensity * color naturally produces the ethereal, translucent look. The jellyfish bell membrane glows brightest at its edges because that's where the Fresnel falloff concentrates the emission — which is physically correct. Gaussian Falloffs — np.exp(-d² / 2σ²) shows up everywhere: sun glow, eye catchlights, atmospheric haze, diffraction spikes on stars, bioluminescent glow halos. Different sigma values for tight core versus wide atmospheric scatter, stacked in layers. The scenes I built, roughly in order of difficulty: 1. Sunset landscape — gradients, FBM clouds, mountain silhouettes, water reflections with noise-based sparkle 2. Deep space nebula — domain-warped FBM gas layers, dark dust lanes, multi-tier star field, bright stars with 6-pointed diffraction spikes 3. Bioluminescent jellyfish — cosine-profile bell domes with Fresnel membrane glow, radial canals, 14 tentacles per jellyfish with individual wave patterns, volumetric god rays, marine snow 4. Human portrait — the hardest by far. SDF geometry, directional lighting with SSS, patterned irises, cupid's bow lips, hair with strand texture. It lands as stylized illustration rather than photorealistic — faces are where pure math hits its ceiling, because humans scrutinize faces like nothing else The only prior work I could find on this was a Towards Data Science article where ChatGPT struggled to produce a smiley face from NumPy arrays. The gap between "smiley face" and "composed scenes with physically-based lighting" is pretty wide. All four scenes are 1920x1080, generated in seconds, using nothing but NumPy and PIL (for the final PNG save). The code is pure Python — no shaders, no rendering engines, no drawing primitives. Just arithmetic on grids of numbers. EDIT: Sorry, it seems I failed to properly attach the images. Trying again. https://preview.redd.it/es10tnh126vg1.png?width=1920&fo

Para usuários Windows, ainda usam o Claude Code no WSL ou nativamente?

Percebi que de uns tempos para cá, o Claude Code evoluiu muito quanto a compatibilidade com Windows nativo, e vira e mexe eu fico alternando entre usá-lo no WSL e usá-lo no Windows nativo em busca de chegar a uma conclusão qual que é melhor. Às vezes uso ainda no WSL devido a compatibilidade com algumas ferramentas que gosto de terminal, como tmux, pra gerenciar várias worktrees e agentes em paralelo. Porém, estou testando também fazer isso usando o Warp com o Claude Code no Windows nativo. Qual a opinião de vocês sobre isso? Tem usado o Claude Code no WSL ou Windows nativo mesmo? submitted by /u/madpeppers013 [link] [comments]