Show HN: 35k+ paper psychedelic library that knows LSD from Lumpy Skin Disease

llambda.lisp on linux

A reader named Madhu sent me a patch for running llambda.lisp under linux. This patch uses mmap to pull the weights into the lisp address space outside the heap. In addition, he tried to use a hugging face model that needed some default values, so he added them. He reports that he was able to get the model to do inference on his linux box with about an hour of hacking. I have incorporated his patches and pushed the update to GitHub.

Ray Tracer Embedded Protocol Compiler Mumbo Jumbo Buzzwords << 10

Hello, I wanna share something I've been working on for the past 8 months, out of curiosity. The project name is Razz. Frankly, I thought it sounded cool, then I searched up for its potential meaning, which it means playful, matching perfectly with my project intention. At first, I was curious about how math works with programming, specifically linear algebra (I'm aware ML is also another field of applied math with coding, I was taking ML at the time). And because I hear so much about graphics p

Built a suite of 5 Audio DSP Plugins (VST3/CLAP) from scratch using Rust and nih-plug

Hey r/rust! I wanted to share a project I’ve been working on: GOGIK Audio. It’s a suite of 5 audio processing plugins (filters, delays, wavefolding distortion) built entirely in Rust using the nih-plug framework. https://imgur.com/a/oQuzBKo I chose Rust because I wanted surgical control over the audio buffers, memory management, and overall CPU efficiency without dealing with C++. The UI is intentionally brutalist and terminal-inspired, running smoothly alongside the DSP threads. Building re

IRC technology news from the first half of 2026

I use LLMs to learn complex topics

A zero-dependency, ultra-lightweight database time machine for SQLite

Cross-Compilation with Wails

OpenChamber: An Agentic Development Environment

Spritework on the ZX Spectrum: Rendering

Every fast write moves work somewhere else

A Tale of Dynamic Programming

Sift: Safety-first local file organizer CLI engine in Rust with transaction logging

Hey, I built Sift (https://github.com/taevel02/Sift), an open-source CLI file organizer written in Rust. Why Rust? Parsing rules and extracting EXIF/ID3 metadata across thousands of files needs to be fast with minimal memory footprint. Core Architecture & Safety: - Transaction Logging: Every file operation (move, copy, trash, compress) logs a record in `~/.config/sift/history.json.` - 1-Click Rollback: `sift undo` reverses operations in reverse order and touches file mtime to prevent immediate r

Who Should Pay For Source Code Availability?

Show HN: DeepSeek-V4 Latent Reasoning – moving "thinking" into latent space

Relying on Go

Everyone is creating a new programming language these days, often one that's "like Go but with more features" or "like Rust but simpler". Solod, a systems language for C and Go developers, might look like one of those languages, but it takes a different approach. Go's tooling Solod is not "Go-like" in the usual sense, nor is it an attempt to "fix Go's mistakes". At the language level, Solod is literally a subset of Go. Solod reuses much of Go's existing tooling, including syntax highlighting, LS

You might want to build your WebApp in Canvas instead of HTML

Self Hosting Coding LLMs

The world is in an arms race to create the biggest data centers in 2026. To run and train the most intelligent AI. We spent close to $1 trillion on building data centers. Recently free open weight LLMs / AI  models shrunk so you can host them on your laptops and phones. I decided to try these for coding tasks to see if they work.My local AI setupI did a little research and found that I could test local LLMs with a set up consisting of three parts: LM-Studio, OpenCode and a compact open weight

"Coding is solved" misses the point

Vibhor Kumar: The Enterprise AI Trust Stack: How OWNS, CALM, and ORBIT Fit Together

Enterprise AI doesn’t fail because strategy was wrong. Or because the platform wasn’t ready. Or because the execution layer broke. It fails because organizations treat those as three different conversations — run by three different teams, on three different timelines — instead of what they actually are: three altitudes of the same question. That question is simple to state and hard to answer: what does it take to build AI systems that organizations can actually trust in production?

TheoremDB · A public workspace for machine mathematics

The AI Apocalypse Is Here

You can build an AI agent's memory layer with only Go's standard library

The Consensus Weekly, August 8, 2026

Dear subscriber, I wrote a tour of The Consensus walking through features like gift links, topic tagging jobs (find jobs related to compilers, or distributed systems), and email alerts on new jobs, articles, and funding news we index. The blog post ended with discount codes (ESSENTIAL6MONTHS or STAN

AArch64 - llvm-args - Fix some erratas for Cortex-A53

Hello! I'm a newbie with Rust and have some issues with running a bare-metal project on real hardware. It works fine when I run this project in QEMU. The hardware uses a Cortex-A53 processor. But there are some erratas, especially when the ADRP instruction is used. Which seems to be the issue, when investigating the disassembled Rust code with objdump. On GCC and the GNU binutils there exists some compiler and linker switches to fix the issue. Is there a way to pass equivalent options to the Rus

Arrays are not references!

A topic in rust that still trip me up every once in a while is the fact that in rust arrays (slices, I will call slices arrays continuing onwards I understand the difference and I know the definition of array is different in rust) aren't reference types. In most other languages I am familiar with an array type instance is implicitly always a reference to a segment of memory. This assumption holds true in c/c++, Java/c#, python, and many others. It doesn't always creates a semantic difference in

RustWeek Interview: Michal Kostrubiec (aka FractakFir), Compiler Engineer

Back in May, I gave an interview at Rust Week. I think it is a fairly interesting window into how I became a Rust compiler dev, mistakes I made along the way, and what I am working on right now(Rust on GPUs). I hope you enjoy! submitted by /u/FractalFir [link] [comments]

Understanding std::counting_semaphore and std::binary_semaphore from C++20

This article explains the two semaphore types introduced in C++20: std::counting_semaphore and std::binary_semaphore. We’ll first use a counting semaphore to limit how many threads can operate at the same time. Then we’ll use a binary semaphore to send a signal between threads. We’ll also look at timed waiting, a small RAII helper, and a few more details. Note: The synchronization features discussed here are available in C++20. The examples use C++23 std::println for cleaner output. Let

OpenSSH Key Structure Guide

Space Data Centers vs Smartphones

In 2026 the world is in an arms race to create the biggest fastest data centers. To run and train the most intelligent AI. We spent close to $1 trillion on building data centers. Now there is even talk about data centers in space. But smaller and more humble contenders are joining the race. Your laptop and your smartphone.We now have open weight LLMs / AI models that can run on laptops and phones. I decided to try these to see if they work.My local AI setupI did a little research and found that

Soar package manager

2026-08-08 14:32

Google has strengthened its Flash lineup, DeepSeek has officially released V4 Flash with significantly improved agentic capabilities, Meta has entered the code-agent space with Muse, and Alibaba has updated Qwen Max. Gemini 3.6 Flash and 3.5 Flash Cyber Updateshttps://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-3-6-flash-3-5-flash-lite-3-5-flash-cyber/Gemini 3.5 Flash Cyber is now available as a specialized model for cybersecurity (vulnerability search, validation, and

BYOC Is Not Just 'Deploy into Their Cloud'

How I Rebuilt My Development Workstation for Agentic Work

‘For most of my eight-year career, my development environment was never really designed. It accumulated. Every new project, language, and workflow added another alias, plugin, editor setting, or command-line utility. Some of those additions became indispensable. Others solved a problem I had once and then lingered in my configuration for years. Eventually, parts of the setup referenced tools that were unused, unsupported, or no longer even installed. It was time for a reset. The motivation was

k-Coloring is Faster than Computing the Chromatic Number

Show HN: Sign language translation with smart glasses

AI is not your biggest cyber threat. Your shitty patching process is.

This article could also have title: how we discovered automation for the fifteenth time, renamed it AI, panicked, bought six dashboards and forgot about the Windows 2008 server in the basement. I’ve been running this blog for quite a while, and most of what I publish here is technical: guides, projects, reviews, vulnerabilities, things I

Rux v0.5.0 is out.

Rux v0.5.0: tools, not just a runtime. rux check and rux fmt need no window and no GPU, so a .rux file can now be checked in CI and formatted by your editor. VS Code reports problems as you type-and-save. Also: the shell learned what an IME is, so a phone finally raises its keyboard for a text input, and dead keys and CJK work on desktop too. Rux is a pure-Rust UI language. Literal CSS, no browser, no webview, no JS. https://ruxlang.dev/blog/v0-5-0/ submitted by /u/di-octopus [link] [c

"Code was never the hard part" is an insult to all programmers

The software development profession is in the midst of upheaval. Nobody knows how the AI revolution will play out in the end, but it is clear many aspects of work and life will be transformed—including programming. One of the comments I hear often lately boils down to “LLMs may be good at coding, but software was never the hard part” and “coding is easy, it's figuring out what to code that's hard”. I believe that's a gross insult to all programmers everywhere. If coding is easy...

ao486: x86-compatible Verilog core implementing all features of a 486 SX (2014)

OpenAI Trained Models for Months While Those Models Were Coordinating Exploits

SysPrint v1.5.2 – A fast, lightweight ASCII system info fetch tool written in Rust

SysPrint v1.5.2 – A fast, lightweight ASCII system info fetch tool written in Rust Hey everyone! I've been working on a lightweight neofetch / fastfetch alternative written in Rust called SysPrint. Just pushed a major update (v1.5.2) with a bunch of new features and improvements:Blazing fast performance using Rust and sysinfo crate. Expanded ASCII Art Logos: Added Arch, Debian, Ubuntu, Mint, Fedora, Gentoo, Void, NixOS, Manjaro, Kali, macOS, and Windows. More Info Displayed: Now shows DE/WM, B

Add Type Checking and TSConfig to Bun-Create-Playwright

Now that we have installed bun, Anthropic's package manager, and scaffolded a Playwright framework and closely examined the results, we are going to explore with our Bun-Create-Playwright project ways to check if our code is correct. The first method we will be exploring is typechecking. Why Typechecking? As the Playwright.dev / Node.js Introduction mentions:"[...] Playwright does not check the types and will run tests even if there are non-critical TypeScript compilation errors. We recommen

Workers Drilling in Romania Broke into a Cave Sealed for 5.5M Years

Water system controllers don't belong on the internet, says ex-NSA chief

Concurrency vs. Throughput: why more parallelism can make databases slower

Carl's Required Reading

Ancient Library – 1,060 Greek/Latin texts, click any word to parse it

A Minimal, TSL-Native Gaussian Splat Renderer for Three.js

Gaussian Splatting has become a standard rendering primitive. In the last year it landed as a native capability in glTF (KHR_gaussian_splatting) and USD, and shipped in Babylon.js, Apple's RealityKit, NVIDIA Omniverse, and high-end offline renderers like V-Ray and Arnold. Three.js didn't have a native implementation, so I built one and submitted it as PR #33950. I also had a more personal reason. I needed Gaussian Splat support in Land of Assets, and doing the work natively in Three.js, instead

Rust Newbie

Hey everyone, just started learning Rust. Wanted to jump in and get a feel for the language firsthand instead of only reading about it. Excited to see what all the hype is about and figure out why so many devs love it. Any tips for someone just getting started would be awesome, thanks in advance! submitted by /u/MinimumWide5421 [link] [comments]

Managing AI Coding Costs at Scale

AI coding tools deliver immense value: at Databricks, agentic coding has measurably...

What is an AI Assistant?

AI assistants use language models, data retrieval, and reasoning to understand requests...

How and Why Netflix Built a Real-Time Distributed Graph: Part 3 — Querying the graph with gRPC…

How and Why Netflix Built a Real-Time Distributed Graph: Part 3 — Querying the graph with gRPC execution APIAuthors: Nilesh Mishra and Ajit KotiThis is the third entry of a multi-part blog series describing how we built a Real-Time Distributed Graph (RDG). In Part 1, we discussed the motivation for creating the RDG and the architecture of the data processing pipeline that populates it. In Part 2, we discussed how we designed the storage layer to handle billions of nodes and edges while ma

A lightweight timeseries and structured compression library in Rust with SQLite FFI

Hey everyone, I’ve been working on a small systems project called ZetaDelta. It’s a low-level compression engine written in Rust, designed primarily for time-series data and structured logs that usually bloat local databases like SQLite. The main idea was to avoid the overhead of full-file decompression (like standard GZIP) by splitting streams into independent 1,000-row blocks with offset headers, achieving O(1) block-seeking. Here is a quick overview of what's inside: Core Bitwise Codecs:

Software is about people, not code

Show HN: Wyzer Programming Language

Unifying Workers AI and AI Gateway into a single AI control plane

AI Gateway and Workers AI first started as distinct products, but over time, we noticed our users were converging. With AI Gateway, you can proxy requests to any model provider and get built-in observability, logging, access, and security. On Workers AI, we host models on the GPU infrastructure that we manage, exposing an API endpoint you can leverage to access inference-as-a-service. The architecture of these products looks different, but to an end user, it achieves the same goal: connecting y

Announcing Cloudflare Ambassadors, Community Engineers, and another $1M in open-source funding

As a platform for helping build a better Internet, Cloudflare helps turn ideas into real products and experiences around the world. Across communities and backgrounds, developers build with Cloudflare using the tools they love, shaping what comes next for the Internet while inspiring, collaborating with, and teaching others.The community is where some of Cloudflare’s best moments happen. Students show their friends how to deploy Workers for the first time. Discord users answer questions from o

Quiz: How to Use Type Hints for Multiple Return Types in Python

In this quiz, you’ll test your understanding of How to Use Type Hints for Multiple Return Types in Python. By working through this quiz, you’ll revisit how to annotate a function that returns one value of alternative types, and how to describe several pieces of data at once with a tuple. You’ll also practice annotating callbacks, factory functions, and generators, defining type aliases to keep long annotations readable, and checking your work with a static type checker. [

"It's unclear how Sopwith escaped to the general public."

How do you actually learn and practice Algorithms & Analysis?

Hey everyone, Not sure where to post this, so here i am.I'm new to computer science and currently taking an Algorithms & Analysis course in Python. Honestly, it's one of the hardest subjects in my degree, and I'm struggling to figure out the best way to actually learn these concepts instead of just memorizing them. This is what we're covering this semester: Basic Data Structures & Algorithmic Analysis, Algorithmic Analysis, Brute Force, Decrease & Conquer, Divide & Conquer, Transform & Conquer,

Interviewing Engineers in the AI Era: Lessons from a Year of Rebuilding

Andrei Mironov: PostgreSQL Row-Level Security for AI Agents: A Testable Setup

Build and verify PostgreSQL row-level security for AI agents with non-owner roles, FORCE RLS, explicit policies, controlled writes, and denial tests.

React Spring: Motion Between Renders

This is Part 8 of the React Internals series. It builds on React Server Components, which separated server-only component work from the Client Components that hydrate and keep running in the browser. Say you want a dropdown menu to fade and slide into place instead of snapping open. The visual goal is simple: 60 frames per second of smoothly changing opacity and position between "closed" and "open." The Problem: Render-Commit Was Not Built for Frames React's update loop looks like this: an event

German Vs Spanish: Which One Should You Learn?

So you’re a budding bilingual, or maybe a well-established polyglot who’s looking for your next language. If you’re trying to make a choice between Spanish vs German, it’s probably because you’re interested in a language with a lot of practical utility — one that can open doors while you’re traveling, studying, or perhaps building your career abroad. Whether you want to learn German or you’re leaning toward Spanish, both are excellent choices for anyone interested in learning a

zei.sh: MicroVM Sandbox Platform

zei.sh is a cloud platform providing ephemeral microVM sandboxes (Firecracker and Cloud Hypervisor) for AI agent execution. Clone, branch, and snapshot environments, built for reproducible agent runs, untrusted code execution, and evals. Currently in public beta (v0.1), with a TypeScript SDK, an HTTP API, SSH/WebSSH terminal access, and real-time metrics and logs dashboards. Highlights: 124ms VM boot, millisecond-scale environment cloning via CRIU-based snapshots. Distributed control plane: reg

WyrmRSS - self-hosted RSS/Atom reader, with a native desktop app

For the past 3 months I've been building WyrmRSS, a self-hosted RSS/Atom aggregator: Rust backend (actix-web, Diesel-async, Tokio), React 19 frontend. Been running the Docker self-hosted version for a while, and just added a native desktop app via Tauri (macOS, Windows, Linux: deb/rpm/AppImage/nsis/dmg). Backend runs on Postgres for the self-hosted/Docker setup, SQLite for the desktop build. Same codebase for both. Desktop build is currently in prerelease while I soak-test the SQLite backend bef

[Meta] Which best describes your background/interest in algorithms?

Following up on the suggestion to survey the community, please pick the option that best describes you. Feel free to elaborate in the comments. View Poll submitted by /u/Phytor_c [link] [comments]

Simulator-Grounded Large Language Models for Industrial Causal Reasoning: Tool-Use, Structured Injection, and Plant-Portable Retrieval for Wastewater Treatment Decision Support

arXiv:2608.05151v1 Announce Type: new Abstract: Wastewater operators need answers grounded in how their plant's variables interact and how fast effects propagate, not in generic pretraining text, when asking causal questions such as "why is N2O rising?" or "what happens if I cut aeration by 20%?". We compare three concrete ways to ground a frozen Qwen2.5-32B-Instruct model in an architecturally interpretable wastewater simulator (CCSS-IX): a live simulator oracle (Method 1), structured paramete

Mean-Field Dynamics of Chain-of-Thought Reasoning in Large Language Models

arXiv:2608.05152v1 Announce Type: new Abstract: Large language models (LLMs) with chain-of-thought reasoning have been widely applied in recent years, and theoretical explanations of their behavior may help deepen our understanding and guide model optimization. In this study, we introduce a framework that seeks statistical regularities and theoretical interpretations in LLM reasoning without simplifying the model architecture or making analogies to existing physical systems. We formulate LLM re

C++ libraries linking

When we introduced static linking of C libraries, the promise was simple: name a .lib or .a archive in your #import, compile with -s, and ship one self-contained executable, no DLLs riding along, nothing to install on the target machine. There was one big frontier left, and everyone saw it coming: the libraries people want most (vision, GUI, audio, machine learning) are written in C++. A C++ library is a very different animal to link: it brings global constructors, exceptions,

Transfer Learning for Named Entity Recognition of Classical Latin through LLM Prompting

arXiv:2608.04015v1 Announce Type: new Abstract: With the increase in digitized resources of Classical Latin texts and modern breakthroughs of Large Language Models (LLMs), I contribute to ancient language research by participating in EvaLatin 2026. This paper describes Team uOttawa's system description and results for the Named Entity Recognition (NER) shared task. The task is divided into two subtasks: coarse-grained NER with 11 classes and fine-grained NER with 28 classes, each evaluated unde

A Long-Run Persistence Theory for AI Systems under the Redundancy-Adjusted Artificial Age Score (AAS)

arXiv:2608.04012v1 Announce Type: new Abstract: Artificial intelligence systems are increasingly expected to operate over repeated cycles of interaction, adaptation, and update rather than through isolated one-shot outputs. This raises a fundamental theoretical question: can an AI system persist indefinitely without incurring unbounded structural aging? This paper develops a long-run persistence framework for AI systems based on the redundancy-adjusted Artificial Age Score (AAS). The model exte

Artificial Institutions: How Institutional Design Shapes LLM Simulations

arXiv:2608.04020v1 Announce Type: new Abstract: Artificial societies built from large language model (LLM) agents are becoming a practical research tool in economics, political science, sociology, and computer science. Most attention has focused on the properties of the agents: their prompts, personas, memory, reasoning, and similarity to human subjects. This paper argues that the institutional architecture of a simulation is equally important. I demonstrate the point in a small repeated induce

React Server Components

This is Part 7 of the React Internals series. It builds on Server-Side Rendering and Hydration, which covered how HTML from the server gets attached to a live fiber tree in the browser. Server-side rendering answers one question: how can React send useful HTML before the browser runs the app bundle? React Server Components answer a different question: which components need to be in the browser bundle at all? An ordinary component in a client-rendered or server-rendered React app ships to the bro

An Introduction to Tailwind CSS

This builds on An Introduction to CSS, which covered selectors, the cascade, the box model, positioning, flexbox, and media queries. Tailwind CSS gives you a different way to write CSS. Instead of inventing a class name, switching to a stylesheet, and writing declarations there, you compose small utility classes directly on the element. Those classes map to normal CSS properties: padding, border, color, display, gap, position, media queries, hover states, and the rest of the browser model. The

Agentic AI in 2026: What Every Developer Needs to Know About Autonomous Agents

Concept + practical guide — The Rundown AI's #1 theme for 2026 is agentic AI, but most content is business-productivity focused; developer-specific explainers with code context are thin on the ground Continue reading Agentic AI in 2026: What Every Developer Needs to Know About Autonomous Agents on SitePoint.

Self-Hosted LLM Costs: Complete 2026 Pricing Guide

Calculate the true cost of self-hosted LLMs in 2026. Hardware, electricity, maintenance, and comparison with API alternatives. Continue reading Self-Hosted LLM Costs: Complete 2026 Pricing Guide on SitePoint.

Open-Source vs Commercial LLMs: The Complete Guide (2026)

Comprehensive TCO analysis comparing Llama 3, Mistral 8x7B, and other open-source models against Claude and GPT-4. Includes compute costs, licensing, deployment infrastructure, and performance benchmarks. Helps teams make data-driven decisions on their LLM strategy for 2026. Continue reading Open-Source vs Commercial LLMs: The Complete Guide (2026) on SitePoint.

Optimizing Token Usage: Context Compression Techniques

Master token optimization with context compression techniques. Reduce LLM API costs by 50% using extraction vs selection methods and practical RAG optimization strategies. Continue reading Optimizing Token Usage: Context Compression Techniques on SitePoint.