<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Mahmoud 🦀</title>
    <description>The latest articles on DEV Community by Mahmoud 🦀 (@wiseai).</description>
    <link>https://dev.to/wiseai</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F827951%2F8d69ab6e-a28d-4d13-9652-bdd2f5eb90f8.png</url>
      <title>DEV Community: Mahmoud 🦀</title>
      <link>https://dev.to/wiseai</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/wiseai"/>
    <language>en</language>
    <item>
      <title>LLM Weights are Hardcoded Intelligence</title>
      <dc:creator>Mahmoud 🦀</dc:creator>
      <pubDate>Sun, 15 Nov 2026 18:55:42 +0000</pubDate>
      <link>https://dev.to/wiseai/llm-weights-are-hardcoded-intelligence-9mk</link>
      <guid>https://dev.to/wiseai/llm-weights-are-hardcoded-intelligence-9mk</guid>
      <description>&lt;p&gt;Hey everyone 👋,&lt;/p&gt;

&lt;p&gt;I need to say something upfront that I know some people are going to push back on, and I want to get the disclaimer out of the way before the argument starts. This post is a critique. Not a hate piece, not a dismissal, and not the kind of hot take that evaporates the moment someone asks a follow-up question. I have been building toward this argument across nearly every AI-related post I have written, from &lt;a href="https://wiseai.dev/blogs/llms-are-usefull-lmms-will-break-reality" rel="noopener noreferrer"&gt;LLMs are Useful. LMMs will Break Reality&lt;/a&gt;, where I tried to be fair about what LLMs genuinely accomplish, to &lt;a href="https://wiseai.dev/blogs/training-is-an-evil-concept-lmms-eliminates-it-altogether" rel="noopener noreferrer"&gt;Training Is an Evil Concept. LMMs Eliminates it Altogether.&lt;/a&gt;, where I argued that the entire training paradigm carries moral weight that the industry refuses to examine, to &lt;a href="https://wiseai.dev/blogs/intelligence-at-rest" rel="noopener noreferrer"&gt;Intelligence at Rest&lt;/a&gt;, where I unpacked what it actually means for a system to store something worth calling intelligence. Each of those posts was pointing at the same underlying problem from a slightly different angle, and in this post I want to point directly at the center of that problem and name it plainly. The problem is this: LLM weights are hardcoded intelligence. And hardcoded intelligence, no matter how impressively hardcoded it is, is not the same thing as intelligence. It is a fossil of intelligence, a snapshot, a frozen record of what the world looked like at training time, compressed into billions of floating-point numbers that will never change again on their own. I am not saying that is worthless. I am saying that is a fundamentally different thing from what people are claiming it is, and the gap between the claim and the reality is exactly where the most dangerous illusions live.&lt;/p&gt;

&lt;p&gt;I want to be honest about my own position before anything else, because I think honesty is the only thing that makes a critique worth reading. I am not an established academic with ten published papers on neural network theory. I am a software engineer who has spent years watching the AI industry make increasingly extravagant promises, using language that is increasingly disconnected from the actual mechanics of what these systems do, and I have watched people bet careers and livelihoods and policy decisions on those promises. I wrote in &lt;a href="https://wiseai.dev/blogs/technology-has-destroyed-my-livelihood" rel="noopener noreferrer"&gt;Technology Has Destroyed My Livelihood&lt;/a&gt; about how the technology industry dismantled things that mattered to people while calling it progress, and the AI industry is doing something very similar right now with the concept of intelligence itself. It is taking a specific, limited, technically impressive capability, compressing it into a word, and selling the word to the world at a markup that the word cannot support. I am writing this post because I think the gap between the word and the reality deserves to be named clearly, and because the alternative I believe in, which is what we have been building with the &lt;a href="https://github.com/wiseaidotdev/lmm" rel="noopener noreferrer"&gt;LMM project&lt;/a&gt;, is real enough and grounded enough to present as an honest alternative. That is what I am going to do in the sections below, and I am going to try to do it without being unfair to the technology I am critiquing.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Weight Is All There Is
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fe9sd2ul6ky0i00gx37eo.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fe9sd2ul6ky0i00gx37eo.jpeg" alt="It's not a brain. It's a very large zip file." width="600" height="494"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Let me start at the most basic technical level, because the argument I am making is ultimately a technical one, and I do not want to dress it in philosophy when the engineering is enough. A large language model, in its final deployed form, is a file. It is a collection of tensors, arrays of floating-point numbers, organized according to a specific architecture. For something like GPT-3, that file contains approximately 175 billion individual float values. For GPT-6, the number is estimated to be in the trillions. Each one of those numbers is the result of an optimization process called gradient descent, which ran over hundreds of billions of tokens of text, adjusting each number very slightly with each pass, until the collective behavior of all the numbers together minimized a loss function called cross-entropy, which measures how well the model predicts the next token in a sequence. When that process ends, the numbers are saved. They are written to disk. They become static. They do not change anymore unless someone runs another round of training or fine-tuning on them. The model is frozen. The numbers are fixed. And that frozen, fixed collection of floats is the entire thing we call the model. There is nothing else. No separate reasoning engine running behind the scenes. No dynamic knowledge base being updated in real time. No living mind deciding what to do next. Just the weights, running forward through the architecture, computing the next token from the previous context, one step at a time.&lt;/p&gt;

&lt;p&gt;What those weights actually encode is a compressed statistical representation of the text they were trained on. During training, the model processes sentences, paragraphs, books, web pages, code repositories, academic papers, forum posts, and every other form of human textual expression that the data collectors could scrape together. For every sequence of tokens, the model is asked to predict what comes next, and when it gets it wrong, the error is propagated backward through the architecture, controlling the weights toward configurations that would have done better. That controlling happens billions of times, and over billions of repetitions, the weights gradually stop being random noise and start being something that reflects the statistical structure of human language and the world knowledge compressed into it. By the end of training, the weights encode things like grammar, syntax, semantics, common reasoning patterns, factual associations, stylistic tendencies, and the statistical relationships between concepts that appear together frequently in text. All of that is real, all of it is genuinely impressive, and I am not going to pretend it is not. But what it is is a statistical model. It is a compression of what has already been said, organized in a way that makes it easy to predict what should come next in a given context. It is not a living engagement with the world. It is a very detailed echo of everything that has been written about the world, frozen at a moment in time, responding to new inputs by pattern-matching them against the patterns it absorbed during training.&lt;/p&gt;

&lt;p&gt;The scale of the resources required to produce this frozen snapshot is staggering, and I think people need to sit with that for a moment before accepting it as a reasonable price to pay. Research on scaling laws, most famously the work by Kaplan and colleagues at OpenAI in 2020, established that the performance of these models follows a power law relationship with model size, training data size, and compute budget (1). The practical implication of that finding was that in order to get better models, you need to train bigger models on more data with more compute, and you need to do it in a way that is roughly compute-optimal, meaning you are not wasting resources by training a large model on too little data or a small model on too much. The subsequent Chinchilla work from DeepMind in 2022 refined these prescriptions further, showing that earlier large models like GPT-3 were actually under-trained relative to their size, and that a smaller model trained on more tokens could outperform a larger model trained on fewer (2). These findings are scientifically interesting and practically important, but they all point in the same direction: more resources, more compute, more energy, more money, and at the end of all of it, you still get a frozen tensor of floating-point numbers. The scale changes. The nature does not.&lt;/p&gt;

&lt;p&gt;The word intelligence, when applied to this frozen tensor, is doing a kind of linguistic heavy lifting that it cannot physically support. Intelligence in humans and animals is not a snapshot. It is a process, a continuous, ongoing interaction between a nervous system and an environment, where the system updates its representations in real time based on new information, corrects errors when they are discovered, forms new hypotheses about the world, and operates with a flexibility that does not depend on having been exposed to every possible situation during some prior training phase. I argued in &lt;a href="https://wiseai.dev/blogs/knowledge-and-intelligence-are-mutually-exclusive" rel="noopener noreferrer"&gt;Knowledge and Intelligence ARE Mutually Exclusive&lt;/a&gt; that knowledge and intelligence are distinct things, and the weight tensor is knowledge in the compressed statistical sense, it is not intelligence in the dynamic operational sense. When people say an LLM is intelligent, what they usually mean is that its outputs look like what an intelligent person would produce in similar circumstances. That is a property of the outputs, not a property of the system that produced them. And the system that produced them is a function, a very large and very complex function, but a function nonetheless, that maps input token sequences to output probability distributions over the vocabulary. That mapping is static. It was fixed when training ended. It is not intelligence. It is the residue of intelligence, left behind by the humans whose writing was absorbed, compressed, and baked into the weights.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fyt71sup1ytc04ajp9m30.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fyt71sup1ytc04ajp9m30.gif" alt="And it will never change again. Ever. Until the next $100M retraining run." width="576" height="325"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I also want to be specific about what this means for the concept of super intelligence, because the original brief for this post asks me to address that, and I think addressing it honestly requires being direct. Super intelligence, in the sense of a system that dramatically exceeds human cognitive capability across all domains, cannot emerge from a frozen weight tensor, regardless of how large that tensor is. The reason is not that the tensor is too small or that the architecture is wrong in some fixable way. The reason is structural. A frozen snapshot of statistical patterns in human text, however comprehensive and however well-compressed, is bounded by what has been written. It can combine and remix what has been written in novel ways, and those combinations can sometimes look like genuine insight, but they cannot exceed the informational ceiling of their training data in any fundamental sense. Super intelligence would require the ability to discover genuinely new things about the world, things that have not been written about, through direct engagement with reality. A frozen weight tensor cannot do that. It can only do what the patterns it absorbed allow it to do, and those patterns, however rich, are always downstream from prior human thought. That is the whole limitation.&lt;/p&gt;

&lt;h2&gt;
  
  
  Fine-Tuning Is Just More Hardcoding
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqfhp6pu89gwejnvucxj2.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqfhp6pu89gwejnvucxj2.jpeg" alt="Pre-training vs fine-tuning, they are literally the same process" width="500" height="559"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;If the pre-training phase is where the weights first crystallize from random noise into something resembling structured knowledge, the fine-tuning phase is where that crystallized structure is polished, redirected, and further locked down. I want to go through the major fine-tuning paradigms carefully, because I think the technical details matter here, and because the way people talk about fine-tuning often obscures what it is actually doing. The first and simplest form is Supervised Fine-Tuning, usually abbreviated SFT. In SFT, the pre-trained model is exposed to a dataset of input-output pairs, usually conversations, instructions and responses, or question-answer pairs, and the weights are adjusted to maximize the likelihood of the correct output given the input. Depending on the approach, either all weights are updated or only a subset, but the result is the same either way: the weights move from their pre-trained configuration to a new configuration that reflects both the pre-training distribution and the fine-tuning distribution, and then they stop. The model is frozen again. What was flexible becomes fixed again, in a slightly different shape. The fine-tuning has hardcoded a new layer of behavior on top of the hardcoded base knowledge, and nothing about that is different in kind from the original training. It is the same process, applied again, at a smaller scale.&lt;/p&gt;

&lt;p&gt;The more sophisticated approach is Parameter-Efficient Fine-Tuning, with LoRA being the most widely deployed example. LoRA, introduced by Hu and colleagues at Microsoft in 2022 and published at ICLR, works by inserting small trainable rank-decomposition matrices into the transformer layers while keeping the original pre-trained weights frozen (3). The motivation is partly computational efficiency, since modifying billions of parameters requires billions of gradient steps and enormous amounts of GPU memory, and partly stability, since modifying the full base model risks catastrophic forgetting. The mathematical formulation is elegant: for each weight matrix W in the original model, LoRA adds a low-rank perturbation Delta W = BA where B and A are small matrices, so the modified forward pass becomes h = Wx + BAx, with only A and B being updated during training while W remains frozen. The result is a model whose base character remains locked in the pre-trained weights, with a thin layer of new behavior overlaid on top through the learned adapters. It is a clever engineering solution to a real resource constraint, and I am not dismissing its technical ingenuity. But I want to be very clear about what it means for the nature of the system. The original hardcoded knowledge base is locked. The fine-tuning layer is a small additional layer of hardcoding placed on top. The system ends up with two layers of frozen numbers, not a dynamic system that learns. The layering is more sophisticated. The fundamental nature is the same.&lt;/p&gt;

&lt;p&gt;Reinforcement Learning from Human Feedback, RLHF, is where the fine-tuning process starts to feel most different from raw training, because it introduces human judgment explicitly into the loop. In RLHF as originally applied to language models, a reward model is first trained to predict which of two model outputs a human would prefer, and then the main model is updated using proximal policy optimization, PPO, to generate outputs that score higher under the reward model. This process is designed to suppress toxic outputs, reduce hallucinations, encourage helpful tone, and generally align the model's behavior with what annotators consider good responses. The updates are small and carefully controlled, using KL-divergence penalties to prevent the policy from drifting too far from the reference model, because drifting too far destroys the linguistic coherence that the original training built up. The key insight for my argument is what the reward model and the PPO updates actually do to the weight tensor. They warp the probability space of the weights, making certain output patterns more likely and others less likely, suppressing the probability mass on responses that the reward model scores low, and reinforcing it on responses that score high. When the RLHF process ends, the weights are frozen again. The warping is permanent until the next fine-tuning run. The model has been further hardcoded, this time in the direction of human preference, but hardcoded nonetheless.&lt;/p&gt;

&lt;p&gt;Direct Preference Optimization, DPO, introduced by Rafailov and colleagues at Stanford and published at NeurIPS 2023, is a mathematically cleaner alternative to the RLHF-PPO pipeline that eliminates the need for a separate reward model and replaces the reinforcement learning loop with a simple classification objective over preference pairs (4). The insight behind DPO is that the optimal policy under RLHF can be expressed analytically in terms of the base model and the reference model, which means you can optimize directly for that policy without needing to train and query a separate reward model. This simplifies the pipeline considerably and makes it much more stable. But from the perspective of my argument, DPO does exactly the same thing as RLHF-PPO in terms of what it does to the weights. It updates the weights in the direction of preferred outputs and away from dispreferred ones, using the reference model as an anchor to prevent catastrophic drift, and when the process ends, the weights are frozen. The mathematical path is different. The destination is identical: a tensor of floats, now encoded with human preference in addition to language statistics and instruction following, frozen and deployed as a static function.&lt;/p&gt;

&lt;p&gt;The most recent addition to this family of hardcoding techniques is Reinforcement Learning with Verifiable Rewards, RLVR, which is used to produce the chain-of-thought reasoning models that have attracted enormous attention over the last year. As described in the DeepSeek-R1 paper, RLVR replaces the human-preference reward signal with a programmatic verifier that checks whether the model's output is correct on tasks with objective ground truth, most commonly mathematics and code (5). Instead of asking humans which of two responses is better, you ask a program whether the model's answer is right. For math, the verifier parses the final numerical result. For code, the verifier runs the code against test cases. The model is trained to maximize the probability of verified-correct outputs, using Group Relative Policy Optimization, GRPO, which compares outputs within a group to estimate relative advantage without needing a separate critic. The remarkable finding from DeepSeek and similar work is that models trained with RLVR spontaneously develop behaviors like extended internal reasoning, self-correction, and backtracking, because those behaviors happen to increase the probability of getting verifiable rewards. This is genuinely impressive. But the mechanism is the same: gradient descent adjusting floating-point weights toward configurations that maximize a loss function, followed by a freeze. The resulting weights encode the tendency to produce extended reasoning chains, in exactly the same way that earlier fine-tuning weights encoded the tendency to avoid toxic outputs. It is a different hardcoded behavior. It is not a qualitatively different kind of system.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fefwgdhqax7ajqw7pi5ed.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fefwgdhqax7ajqw7pi5ed.jpeg" alt="Layer after layer of fine-tuning. Still a frozen tensor at the end." width="653" height="383"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The cumulative picture from all of these fine-tuning stages is a system whose weights have been adjusted by multiple overlapping optimization processes, each running for a time and then stopping, leaving behind a frozen artifact that reflects all of the influences applied to it. Pre-training deposits the foundational layer of language and world knowledge. SFT deposits a layer of instruction-following behavior. RLHF or DPO deposits a layer of human preference alignment. RLVR deposits a layer of structured reasoning behavior. Each layer is real, each is technically sophisticated, and each is hardcoded, frozen, unable to update itself in response to new information unless a new training run is explicitly launched. The resulting system is not a mind that grows and changes with its experience. It is a stack of frozen optimization artifacts, layered on top of each other, each one a snapshot of what gradient descent produced given a particular dataset, objective, and compute budget. I do not say this to be reductive. I say it because the distinction between a stack of frozen snapshots and a mind that actually learns from experience is the most important distinction in this entire conversation, and collapsing it is how you end up with AI products that fail in unpredictable ways when reality does not match the training distribution.&lt;/p&gt;

&lt;h2&gt;
  
  
  LLMs Are Very Sophisticated Compilers
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7a2r3mqdeubz4wmd0uyy.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7a2r3mqdeubz4wmd0uyy.jpeg" alt="LLM is basically GCC but for English" width="578" height="433"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I want to offer an analogy here, and I want to be careful about it, because analogies are always imperfect and I do not want to overextend this one. But I think the compiler analogy captures something real about what LLMs actually do, and it is worth spelling out carefully. A compiler takes source code written in a high-level language and transforms it into a lower-level representation, machine code or bytecode, that can be executed efficiently. It is a deterministic transformation, mostly, that maps one form of text to another. The compiler does not understand the program in any meaningful sense. It applies a set of rules, transformations, optimizations, and validations to the input text and produces an output according to those rules. The same input, run through the same compiler with the same flags, produces the same output every time. If the input is malformed, the compiler produces an error or a garbage output, because it has no way to understand intent, only to apply its rules. The rules are good and the transformations are sophisticated, but the process is fundamentally mechanical. No understanding lives anywhere in the compilation pipeline.&lt;/p&gt;

&lt;p&gt;LLMs are doing something that is structurally analogous, except the mapping is from human-language text to human-language text instead of from source code to machine code, and the transformation is probabilistic instead of deterministic. When you give an LLM a prompt, the model converts the prompt tokens into a high-dimensional embedding, processes that embedding through hundreds of layers of attention and feed-forward operations, and produces a probability distribution over the vocabulary at each step, from which the next token is sampled. The token is appended to the context, and the process repeats until a stopping condition is met. At no point in this pipeline does any part of the system access the external world. At no point does it consult a physical ground truth. At no point does it check whether its output is true. It maps the input tokens to output tokens according to the statistical patterns encoded in its weights, in the same way that a compiler maps input tokens to output tokens according to the grammatical and semantic rules encoded in its transformation tables. The analogy is imperfect because the LLM's mapping is learned rather than hand-coded, and because it is probabilistic rather than deterministic. But the fundamental structure is the same: a transformation applied to text, producing text, with no grounding in anything beyond the patterns absorbed during the system's construction.&lt;/p&gt;

&lt;p&gt;This analogy helps explain something that I think a lot of people find genuinely puzzling about LLMs, which is why they hallucinate so confidently and so fluently. When a compiler encounters ambiguous input, it usually fails loudly, producing a compilation error that tells you something went wrong and where. It does not silently emit code that looks right but does the wrong thing, at least not usually. An LLM has no such failure mode. When the model encounters a prompt for which the correct answer lies outside or at the edges of its training distribution, it does not say "I don't know" unless it was specifically trained to do so in similar situations. Instead, it does what it always does: it samples from the probability distribution its weights assign to the next token given the context, and that sampling produces something fluent, something that looks grammatically correct and topically relevant, because fluency and topical relevance are properties the model was trained to maximize. The hallucination is not a bug in the sense of an unexpected deviation from intended behavior. It is the intended behavior applied to a situation where the intended behavior produces a wrong answer. The model is doing what it was designed to do, mapping input to statistically plausible output, and the mapping happens to be wrong because the right answer was not statistically dense enough in the training data to dominate the output distribution. This is what a compiler would do if you asked it to compile a legal-looking but semantically empty program: it would produce output faithfully, applying its rules correctly, and the output would be meaningless, because the input was meaningless, and the compiler has no way to know the difference.&lt;/p&gt;

&lt;p&gt;The compiler analogy also illuminates something important about the nature of novelty in LLM outputs. Compilers can produce machine code that the compiler authors never explicitly wrote, because the compiler generates code according to rules that apply across all possible valid inputs. In the same way, LLMs can produce text that was never written by any human in that form, because the model generates tokens according to statistical patterns that apply across all possible prompt contexts. This can look like creativity, and sometimes it is creativity in a meaningful sense, the same way a jazz musician improvising is creative even though they are drawing on learned patterns, scales, and harmonic structures. But there is a limit to how far the analogy goes. The jazz musician has access to the external world. They can hear the audience, respond to the room, play something they have never played before because they were moved by something genuinely new that happened in that moment. The LLM cannot do this. Its weights were fixed before the conversation started. The statistical patterns it draws on are entirely contained within the training distribution. What looks like responding to novelty is actually pattern-matching the novel input to the nearest familiar pattern and generating the statistically expected continuation of that pattern. That is a form of creative output, but it is not the same kind of creativity as engaging with genuine novelty in the world, and the difference is not academic. It is the difference between a system that can be surprised and a system that cannot. And a system that cannot be surprised cannot learn, because learning is fundamentally about being surprised and updating in response to surprise.&lt;/p&gt;

&lt;p&gt;I also want to address the argument that chain-of-thought reasoning somehow breaks the compiler analogy, because I know that is coming. Chain-of-thought reasoning is the technique, now standard in modern reasoning models, of prompting the model to generate intermediate reasoning steps before producing a final answer. The intuition behind it is that by externalizing the reasoning process into the context window, the model gets to build on its own intermediate outputs, which allows it to tackle multi-step problems that it could not handle in a single forward pass. This is real and it works, and I am not dismissing it. But the chain-of-thought tokens are still tokens. They are still generated by the same process, applying the same frozen weights to the same probability distribution. The intermediate steps are part of the input context, and the model processes them in the same way it processes any other input context. There is no separate reasoning engine that becomes active during chain-of-thought. There is no executive function that evaluates whether the reasoning is actually valid before continuing. There is just the weight tensor, mapping longer and longer contexts to next-token probability distributions. The reasoning can be wrong. It can go in circles. It can reach a confident but incorrect conclusion after a flawless-looking chain of steps, because at no point does any part of the pipeline check the reasoning against reality. The chain-of-thought makes the hallucination longer and more elaborate. It does not make it less possible.&lt;/p&gt;

&lt;p&gt;I also need to say something about retrieval-augmented generation, RAG, because it is the most common objection to the claim that LLMs are purely closed functions over their training data. RAG systems augment the model's input context with retrieved documents from an external database, which means the model can access information that was not present in its training data. This is real and it mitigates some of the limitations I have been describing. But it does not fundamentally change the character of what the model is doing. The retrieved documents become part of the input context, and the model processes them using the same frozen weights, applying the same statistical patterns, to produce the next token. The model is now a text-to-text function that has been given a larger input, not a system that has fundamentally changed its relationship with the external world. The weights are still frozen. The function is still the same function. The input is richer, and the output is therefore better-grounded in some cases, but the mechanism is unchanged. RAG makes the compiler smarter by giving it better documentation to work with. It does not turn the compiler into a programmer who actually understands the code. And the distinction between working with better documentation and actually understanding something is the distinction that my entire argument rests on.&lt;/p&gt;

&lt;h2&gt;
  
  
  Training Is Irrelevant and Obscenely Expensive
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fw4u0z6yaxc6pdltpp0su.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fw4u0z6yaxc6pdltpp0su.gif" alt="Spending $1T to produce a file that knows nothing about last Monday" width="576" height="433"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I said in &lt;a href="https://wiseai.dev/blogs/training-is-an-evil-concept-lmms-eliminates-it-altogether" rel="noopener noreferrer"&gt;Training Is an Evil Concept. LMMs Eliminates it Altogether.&lt;/a&gt; that training is evil in a specific and carefully defined sense, meaning that it is a systemic practice that externalizes enormous costs onto people who did not choose to bear them, while concentrating the benefits in the hands of a small number of powerful institutions. I stand by everything I said in that post, and I am not going to repeat all of those arguments here. But I want to add something new in this post, something that connects the moral case to the technical case I have been building in the previous sections. The connection is this: not only is training morally costly in the ways I described before, it is also technically useless in a specific and important sense. It is useless because the thing it produces, a frozen weight tensor, is not durable. It decays. It goes stale. It gradually stops being accurate as the world changes, because the world continues to change and the weights do not. And the response to this decay is to train again, consuming the same enormous resources, producing another frozen tensor, which will also decay, requiring another training run, and so on, in a treadmill that never terminates because the world never stops changing. The training paradigm does not solve the problem of machine knowledge. It defers it. It produces a temporary approximation that must be replaced regularly, at enormous cost, without ever achieving the kind of continuous, grounded, self-updating knowledge that actually knowing something requires.&lt;/p&gt;

&lt;p&gt;The financial and environmental cost of this treadmill is real and documented, and I think people need to understand the numbers concretely before they accept "more training" as the default answer to every AI limitation. Training GPT-3 required approximately 1,287 megawatt-hours of electricity, generating an estimated 552 metric tons of carbon dioxide equivalent, the lifetime emissions of roughly 120 passenger cars (6). Independent research into AI's water footprint found that the same training run consumed an estimated 700,000 liters of freshwater for data-center cooling, a figure that Patterson's paper does not report but that subsequent environmental audits of the same infrastructure have documented. GPT-4 required substantially more resources; according to industry analysis by SemiAnalysis and confirmed by Sam Altman himself, the compute cost of training GPT-4 alone was somewhere between $70 million and $100 million, running roughly 25,000 NVIDIA A100 GPUs continuously for approximately three months. The carbon footprint of GPT-4's training run is independently estimated at somewhere between 12,000 and 15,000 metric tons of CO₂ equivalent, roughly three to four times the annual emissions of a mid-sized coal power plant, and that figure covers only the final training run, not the failed experiments, iterative ablations, and alignment fine-tuning that surrounded it. These are not costs that are borne equally. They are costs that are borne primarily by the planet and by the communities that live near data centers and power plants, while the benefits flow primarily to the technology companies that can afford the compute. I argued in &lt;a href="https://wiseai.dev/blogs/technology-has-destroyed-my-livelihood" rel="noopener noreferrer"&gt;Technology Has Destroyed My Livelihood&lt;/a&gt; that the tech industry has a habit of externalizing cost while internalizing benefit, and the training paradigm is one of the clearest examples of that dynamic at scale.&lt;/p&gt;

&lt;p&gt;Beyond the environmental cost, there is the cost of the data itself. The data used to train these models was collected from the internet, from books, from code repositories, from academic papers, from every form of human intellectual and creative work that could be scraped and processed. As I argued in my previous post on training, this collection process happened largely without the consent of the people who produced the original work, and it has been the subject of significant legal challenges in multiple jurisdictions. Writers, visual artists, software engineers, and academic researchers have all filed cases arguing that using their work to train AI systems without permission or compensation is a violation of their rights, including the Authors Guild class action against OpenAI filed in September 2023, joined by John Grisham, George R.R. Martin, and Jonathan Franzen, and the New York Times lawsuit against OpenAI and Microsoft filed in December 2023 (7). These cases are ongoing and unresolved, but their existence alone should tell us something: the training paradigm depends on a supply of human creative and intellectual labor that it did not pay for and did not ask for, and the people who produced that labor are increasingly aware of this and increasingly angry about it. The model weights encode this labor. Every parameter that encodes something about how to write an essay or how to solve a coding problem reflects the absorbed output of a human who spent time and effort producing that essay or solving that problem, and none of those humans were compensated or even acknowledged. That is a structural description of how the value in these systems was produced.&lt;/p&gt;

&lt;p&gt;The obsolescence problem is the one that I think gets the least attention in the mainstream AI conversation, and it is arguably the most practically significant. A model trained with a knowledge cutoff in one year is already partially wrong about the world by the time it is deployed six months later, and it becomes increasingly wrong with every passing month as the world continues to change while the weights do not. Scientific papers are published. Laws are enacted. Companies rise and fall. People die and are born. Discoveries are made. World records are broken. All of this happens outside the model's awareness, because the model has no awareness, only frozen weights that reflect the state of the world as described in the text available before the training cutoff. The standard solution is to retrain periodically, but periodic retraining is expensive, it does not solve the problem continuously, and it creates a knowledge discontinuity at every retraining boundary where the model's understanding of events before and after the cutoff has different quality and reliability. The alternative currently being explored is retrieval augmentation, as I discussed earlier, which helps at the margins but does not change the fundamental character of the system. Neither approach gives you a system that actually knows what is happening in the world right now, because knowing what is happening right now requires continuous engagement with the world, not periodic snapshots of text descriptions of the world.&lt;/p&gt;

&lt;p&gt;There is also a finer form of obsolescence that I think is underappreciated, which is the obsolescence of the patterns themselves, not just the facts. The world is not just a collection of facts that change over time. It is a collection of relationships, norms, practices, technologies, and social structures that evolve, and the patterns of human writing about the world evolve with them. A model trained on 2024 text has absorbed the statistical patterns of 2024 writing, which reflects 2024 assumptions, 2024 terminology, 2024 consensus beliefs, and 2024 rhetorical conventions. By 2026, some of those assumptions are outdated, some of that terminology has shifted in meaning, some of those consensus beliefs have been overturned, and some of those rhetorical conventions have changed. The model's weights encode all of this as if it is current, because the weights do not know that time has passed. This is a matter of the entire frame of reference being outdated, and that kind of outdatedness is harder to fix with retrieval augmentation because it is not a matter of lacking specific facts. It is a matter of having the wrong background against which to interpret new facts. And the only way to fix it is to train again, absorbing new patterns, at enormous cost, producing a new frozen tensor that will also eventually go stale.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F11w2ojan6qm8len3fclk.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F11w2ojan6qm8len3fclk.gif" alt="More compute. Same frozen limitation. Train again. Repeat." width="513" height="598"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I want to be clear that I am not making an argument that progress is impossible or that AI development should stop. I am making an argument that the specific approach of encoding intelligence by training on massive text corpora and freezing the result is a fundamentally limited approach that becomes more expensive and less maintainable over time, not less. The cost per unit of capability improvement has not decreased as models have gotten larger. It has increased. The Kaplan scaling laws show diminishing returns in the sense that you need exponentially more compute to get linear improvements in model performance (1). That means the training treadmill gets faster and more expensive with every iteration, while the fundamental limitation, the frozen weight tensor that cannot engage with the world in real time, remains unchanged. At some point, the question has to be asked: is this the right approach, or is it the most visible approach, the most fundable approach, the approach that happens to match the incentive structures of venture-backed technology companies, and therefore the approach that gets all the resources and attention regardless of whether it is the best path forward? I think the evidence is increasingly pointing toward the latter, and I think the alternative I am about to describe points toward something genuinely different.&lt;/p&gt;

&lt;h2&gt;
  
  
  LMM: Learning on the Fly With Deterministic Math
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foibz9oultyh2ms5cz57u.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foibz9oultyh2ms5cz57u.jpeg" alt="What if instead of training we just... did math?" width="680" height="477"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Let me tell you about something I have been building, carefully and quietly, alongside all of these blog posts. It is called LMM, Large Mathematical Model, and it is available as an open-source Rust crate at &lt;a href="https://github.com/wiseaidotdev/lmm" rel="noopener noreferrer"&gt;https://github.com/wiseaidotdev/lmm&lt;/a&gt;. I want to be as honest about it as I have been about everything else in this post, which means I am going to tell you what it is and what it is not, without the marketing language that I have been complaining about throughout this series. LMM is not a production replacement for GPT-5. It is not going to write your novel or pass your bar exam or run your company's customer support queue. What it is is a proof of concept, and the concept it proves is specific and important: that a system can perceive inputs, discover mathematical structure within them, reason causally about that structure, and generate language output, all without training on a single human-authored document, without a gradient descent step across a corpus of scraped creative work, and without any GPU at all. That last point matters more than it might seem, because running on consumer CPUs is a democratic statement. It means anyone can run this, not just the institutions that can afford datacenters.&lt;/p&gt;

&lt;p&gt;The architecture of LMM is organized around a fundamentally different relationship between the system and knowledge. Where an LLM bakes knowledge into weights during a training run and then freezes it, LMM discovers knowledge on the fly from the specific inputs it receives at runtime, using deterministic mathematical methods that are transparent, verifiable, and inherently grounded in the structure of the data. The entry point for most interactions is the TRAM pipeline, which stands for Text Reasoning and Applied Mathematics. When a user submits a query, TRAM begins by launching a web prefetch process, using DuckDuckGo's Instant Answer API and Wikipedia to retrieve current, real-world information relevant to the query. That information is passed through a &lt;code&gt;SentenceFilter&lt;/code&gt; that discards low-information-density content, metadata fragments, and disambiguation artifacts before anything enters the knowledge store. What survives is ingested into a &lt;code&gt;KnowledgeIndex&lt;/code&gt; using IDF-weighted term frequency scoring. The knowledge index is not a frozen artifact. It is built fresh for each session from whatever the web returns today. That is a fundamentally different relationship with currency and accuracy than a frozen weight tensor has, because the information the system works with reflects the current state of the web at query time, not the state of a text scrape from two years ago.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;Adaptive Thought Engine&lt;/code&gt;, ATE, is one of the most distinctive parts of the TRAM pipeline. When invoked with the &lt;code&gt;--think&lt;/code&gt; flag, the ATE classifies the user's prompt into one of eight reasoning modes: factual, causal, procedural, analogical, definitional, exploratory, evaluative, or task. This classification is deterministic, based on syntactic and semantic features of the prompt text, and it determines how the subsequent reasoning proceeds. For a factual prompt, the ATE fires targeted queries to retrieve relevant verifiable information. For a causal prompt, it generates hypotheses about causal structure and constructs evidence chains. For an evaluative prompt, it identifies the dimensions of evaluation and retrieves comparative information. The key point is that the reasoning structure is determined by the prompt at runtime, not baked into weights during training. The system does not have a frozen prior about how to answer causal questions. It has a principled procedure for how to approach them, implemented in deterministic code, and that procedure runs fresh every time against freshly retrieved information. The ThinkLoop then implements a PID-style closed-loop reasoning process, where a &lt;code&gt;Reflector&lt;/code&gt; formulates queries, a &lt;code&gt;SearchOracle&lt;/code&gt; fetches results, and a &lt;code&gt;CognitionSignal&lt;/code&gt; measures the Jaccard distance between successive iterations to determine whether the system is converging on a satisfactory answer. It keeps iterating until convergence or until it detects a stall, at which point it reports what it found.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxb8dxs189wgxwqyzcogh.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxb8dxs189wgxwqyzcogh.gif" alt="No GPU was harmed in the generation of this output" width="360" height="202"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  LMM and the Path Ahead
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F28ndlhpjfc1ppl0dwzvx.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F28ndlhpjfc1ppl0dwzvx.jpeg" alt="A proof of concept, not a finished system, but that's the whole point" width="771" height="325"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I want to be careful here, because the conclusion of this post could very easily slide into the kind of overclaiming that I have been critiquing throughout. LMM is currently a proof of concept and a work in progress project. It is not a finished system yet. It does not outperform GPT-6 on most benchmarks. It is not ready to replace a trained language model for the production applications where those models are currently used. I want to say all of that clearly and without dodging, because I have argued throughout this series that intellectual honesty is the minimum standard, and I am not going to lower that standard for my own project. What LMM is, specifically and verifiably, is a demonstration that the core capabilities associated with language AI, text encoding, text generation, question answering, causal reasoning, and mathematical equations applied to data, can all be implemented without training on human-authored text, without gradient descent, without GPUs, and without any of the ethical costs that the training paradigm makes unavoidable. That demonstration is real. The code runs. The outputs are reproducible. The ARC-AGI-3 score of 14.55% is documented and publicly verifiable at the ARC Prize leaderboard. That is a result achieved without any training whatsoever, by a system running on a laptop CPU, and that is the point.&lt;/p&gt;

&lt;p&gt;The architectural direction that LMM represents is, I believe, more honest than the direction the mainstream AI industry is pursuing, and I want to explain what I mean by honest in this context. When an LLM produces an output, the output emerged from a process that is essentially opaque: trillions of parameters computed an enormous number of matrix multiplications and produced a probability distribution, from which a token was sampled. You cannot trace the output back to any interpretable intermediate step. You cannot verify the reasoning by examining the internal representations. You cannot ask the system why it said what it said in a way that produces a verifiable answer, because the system does not have a why that exists in any interpretable form. The output either corresponds to what is in the world or it does not, and you need external validation to know which. When LMM produces an output, the output is the result of a chain of deterministic computations that are exposed: a retrieved set of documents, an IDF-weighted knowledge index, an inference chain through IF-THEN rules, a symbolic expression discovered by GP regression, a causal propagation through an explicit graph. Every step is inspectable. Every step can be validated. The system shows the work, and showing the work is what makes the answer auditable. Auditable AI is scientifically preferable, because science requires that claims be verifiable, and a claim produced by a process that cannot be examined is a claim that cannot be verified.&lt;/p&gt;

&lt;p&gt;The comparison between LMMs and LLMs is not, at this stage, a comparison between equals. I need to be honest about that because pretending otherwise would be exactly the kind of marketing I have been criticizing. The comparison is between a mature, heavily resourced paradigm with years of engineering investment and billions of dollars of compute, and an early-stage, resource-constrained alternative being developed by a small team as an open-source project. That is not a fair fight on benchmarks, and I am not asking you to judge it on benchmarks. I am asking you to judge it on principles. The LLM paradigm is mature and capable at the cost of opacity, ethical problems, environmental impact, data obsolescence, and the fundamental limitation that the weights are frozen at training time and cannot genuinely engage with the world in real time. The LMM paradigm is early and limited at the cost of less fluency and narrower coverage, in exchange for transparency, auditability, training-free operation, CPU-only accessibility, continuous learning from live data at runtime, and grounding in mathematical structure that is verifiable. I believe the second set of trade-offs is better for the long-term development of AI that is genuinely trustworthy and genuinely useful, and I believe that because I have spent years watching the first set of trade-offs produce systems that people trust more than they should and that fail in ways that could have been anticipated by anyone who understood the architecture.&lt;/p&gt;

&lt;p&gt;The connection to previous threads in this blog is something I want to draw out explicitly, because I have been building toward this conclusion for a long time and I want people who have been following along to see how the pieces fit together. In &lt;a href="https://wiseai.dev/blogs/language-is-limited-asi-is-impossible" rel="noopener noreferrer"&gt;Language is Limited. ASI is Impossible.&lt;/a&gt;, I argued that language is a compression of thought, not thought itself, and that any system built purely on language inherits the gap between the symbol and the reality it represents. LMM's approach to reducing that gap is not to use more language but to go below language, to mathematical structure that encodes mechanism rather than surface description. In &lt;a href="https://wiseai.dev/blogs/mathematical-equations-are-multimodal-by-default" rel="noopener noreferrer"&gt;Mathematical Equations are Multimodal by default&lt;/a&gt;, I argued that a single equation encodes multiple modalities simultaneously because it encodes the mechanism that generates all of them. LMM's symbolic regression engine is precisely the tool that discovers those equations from data, closing the loop between the theoretical argument and the practical implementation. In &lt;a href="https://wiseai.dev/blogs/intelligence-at-rest" rel="noopener noreferrer"&gt;Intelligence at Rest&lt;/a&gt;, I argued that the quality of a system's resting intelligence is determined by how efficiently its structure encodes the domain, and that compression is the true measure of intelligence. LMM's symbolic regression produces the most compressed possible representation of the patterns in its data, an equation, while LLM training produces a statistical compression that is both larger and less interpretable. In &lt;a href="https://wiseai.dev/blogs/no-neural-networks-cannot-produce-genuine-autonomous-intelligence" rel="noopener noreferrer"&gt;No, Seriously. Neural Networks Cannot Produce Genuine Intelligence.&lt;/a&gt;, I argued that genuine autonomy requires the ability to discover new structure in novel domains without prior training for that specific domain. LMM's GP-based equation discovery does exactly this: it encounters new data and finds the mathematical structure in it, without having been trained on examples from that domain. Each of those arguments was pointing here.&lt;/p&gt;

&lt;p&gt;I also want to say something about what bias-free by design actually means in the context of LMM, because it is a phrase that gets used loosely in the AI discourse and I want to be specific about it. When I say LMM is bias-free by design, I do not mean that the system is neutral in some impossible, view-from-nowhere sense. I mean that the system does not absorb and reproduce the statistical biases of its training data because it has no training data. The knowledge it works with at runtime is retrieved live from the web, which is itself biased in many ways, and those biases can influence the outputs. The expert system's IF-THEN rules are derived from retrieved knowledge, which carries the biases of its sources. These are real limitations and I am not pretending otherwise. What LMM eliminates is a specific, documented, structural form of bias: the bias that is baked into static weights during training on a fixed, historically produced dataset, the bias that cannot be updated without retraining, the bias that affects every output of the system regardless of what the user provides as input. Research has consistently shown that this form of structural bias in trained language models is real, persistent, and difficult to mitigate without fundamentally changing the training process (8). Blodgett and colleagues, in their 2020 ACL survey of 146 papers on bias in NLP systems, found that the statistical patterns embedded in model weights during training systematically encode the language ideologies and social hierarchies present in the training data, penalizing speakers of non-dominant language varieties and reproducing historical inequalities in every inference pass, not as an edge case, but as a structural feature. LMM does not solve the problem of bias in AI. It eliminates one of its most rooted sources.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F91qxtn51b1pj2y7h7u7n.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F91qxtn51b1pj2y7h7u7n.jpeg" alt="Hardcoded intelligence is a fossil. We're building something alive." width="500" height="375"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;If I am being fully honest, and I have promised to be, the path ahead for LMM involves months of research and development before it can compete with trained language models on the full range of tasks that users expect AI systems to handle. The language generation pipeline needs to produce more fluent and contextually appropriate text as a function of the mathematical structures it discovers. These are substantial research challenges, and I am not going to pretend they will be solved quickly or easily. But I want to put on record that they are solvable in principle, that they do not require the ethical compromises that training requires, and that solving them would produce a system that is more transparent, more trustworthy, more auditable, and more grounded in physical reality than any system produced by the training paradigm. That is the promise I believe in, and it is a promise I am working to keep. The weights of an LLM are hardcoded intelligence, and hardcoded intelligence, however impressive, is a limitation masquerading as a capability. The alternative is intelligence that is alive, that updates from the world in real time, that shows its work, and that can be verified. That is what we are building. And that is worth building.&lt;/p&gt;

&lt;p&gt;Till next time 👋!&lt;/p&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;p&gt;&lt;span id="ref-1"&gt;&lt;/span&gt; &lt;strong&gt;(1)&lt;/strong&gt; Kaplan, J., McCandlish, S., Henighan, T., Brown, T. B., Chess, B., Child, R., Gray, S., Radford, A., Wu, J., &amp;amp; Amodei, D. (2020). Scaling Laws for Neural Language Models. &lt;em&gt;arXiv preprint arXiv:2001.08361&lt;/em&gt;. &lt;a href="https://arxiv.org/abs/2001.08361" rel="noopener noreferrer"&gt;https://arxiv.org/abs/2001.08361&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-2"&gt;&lt;/span&gt; &lt;strong&gt;(2)&lt;/strong&gt; Hoffmann, J., Borgeaud, S., Mensch, A., Buchatskaya, E., Cai, T., Rutherford, E., Casas, D. d. L., Hendricks, L. A., Welbl, J., Clark, A., Hennigan, T., Noland, E., Millican, K., van den Driessche, G., Damoc, B., Guy, A., Osindero, S., Simonyan, K., Elsen, E., ... Sifre, L. (2022). Training Compute-Optimal Large Language Models. &lt;em&gt;arXiv preprint arXiv:2203.15556&lt;/em&gt;. &lt;a href="https://arxiv.org/abs/2203.15556" rel="noopener noreferrer"&gt;https://arxiv.org/abs/2203.15556&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-3"&gt;&lt;/span&gt; &lt;strong&gt;(3)&lt;/strong&gt; Hu, E. J., Shen, Y., Wallis, P., Allen-Zhu, Z., Li, Y., Wang, S., Wang, L., &amp;amp; Chen, W. (2021). LoRA: Low-Rank Adaptation of Large Language Models. &lt;em&gt;International Conference on Learning Representations (ICLR 2021)&lt;/em&gt;. &lt;a href="https://arxiv.org/abs/2106.09685" rel="noopener noreferrer"&gt;https://arxiv.org/abs/2106.09685&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-4"&gt;&lt;/span&gt; &lt;strong&gt;(4)&lt;/strong&gt; Rafailov, R., Sharma, A., Mitchell, E., Ermon, S., Manning, C. D., &amp;amp; Finn, C. (2023). Direct Preference Optimization: Your Language Model is Secretly a Reward Model. &lt;em&gt;Advances in Neural Information Processing Systems (NeurIPS 2023)&lt;/em&gt;. &lt;a href="https://arxiv.org/abs/2305.18290" rel="noopener noreferrer"&gt;https://arxiv.org/abs/2305.18290&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-5"&gt;&lt;/span&gt; &lt;strong&gt;(5)&lt;/strong&gt; DeepSeek-AI. (2025). DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. &lt;em&gt;arXiv preprint arXiv:2501.12948&lt;/em&gt;. &lt;a href="https://arxiv.org/abs/2501.12948" rel="noopener noreferrer"&gt;https://arxiv.org/abs/2501.12948&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-6"&gt;&lt;/span&gt; &lt;strong&gt;(6)&lt;/strong&gt; Patterson, D., Gonzalez, J., Le, Q. V., Liang, C., Munguia, L.-M., Rothchild, D., So, D. R., Texier, M., &amp;amp; Dean, J. (2022). The Carbon Footprint of Machine Learning Training Will Plateau, Then Shrink. &lt;em&gt;IEEE Micro, 42&lt;/em&gt;(4), 18-28. &lt;a href="https://arxiv.org/abs/2204.05149" rel="noopener noreferrer"&gt;https://arxiv.org/abs/2204.05149&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-7"&gt;&lt;/span&gt; &lt;strong&gt;(7)&lt;/strong&gt; "Authors Guild V. OpenAI Inc., 1:23-cv-08292 - CourtListener.com." n.d. CourtListener. &lt;a href="https://www.courtlistener.com/docket/67810584/authors-guild-v-openai-inc" rel="noopener noreferrer"&gt;https://www.courtlistener.com/docket/67810584/authors-guild-v-openai-inc&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-8"&gt;&lt;/span&gt; &lt;strong&gt;(8)&lt;/strong&gt; Blodgett, S. L., Barocas, S., Daumé III, H., &amp;amp; Wallach, H. (2020). Language (Technology) is Power: A Critical Survey of "Bias" in NLP. &lt;em&gt;Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics (ACL 2020)&lt;/em&gt;, pp. 5454-5476. &lt;a href="https://aclanthology.org/2020.acl-main.485" rel="noopener noreferrer"&gt;https://aclanthology.org/2020.acl-main.485&lt;/a&gt;&lt;/p&gt;

</description>
      <category>llm</category>
      <category>lmm</category>
      <category>ai</category>
      <category>science</category>
    </item>
    <item>
      <title>Using Evil Spirits To Cast Out Evil Spirits!</title>
      <dc:creator>Mahmoud 🦀</dc:creator>
      <pubDate>Fri, 06 Nov 2026 11:11:37 +0000</pubDate>
      <link>https://dev.to/wiseai/using-evil-spirits-to-cast-out-evil-spirits-4jjg</link>
      <guid>https://dev.to/wiseai/using-evil-spirits-to-cast-out-evil-spirits-4jjg</guid>
      <description>&lt;p&gt;Hey everyone 👋,&lt;/p&gt;

&lt;p&gt;This post is something I have been sitting on for a while, and I am finally writing it because the contradiction at the center of everything I do has become too loud to ignore. I have spent months arguing that large language models are not intelligence, that they are a sophisticated statistical cage wrapped in confident composition, that they compress knowledge without touching truth, and that the world is being sold a very expensive lie about what these systems can and cannot do. I have made that argument in &lt;a href="https://wiseai.dev/blogs/llms-are-usefull-lmms-will-break-reality" rel="noopener noreferrer"&gt;LLMs are Useful. LMMs will Break Reality&lt;/a&gt;, in &lt;a href="https://wiseai.dev/blogs/mathematical-equations-are-multimodal-by-default" rel="noopener noreferrer"&gt;Mathematical Equations are Multimodal by Default&lt;/a&gt;, in &lt;a href="https://wiseai.dev/blogs/language-is-limited-asi-is-impossible" rel="noopener noreferrer"&gt;Language is Limited. ASI is Impossible.&lt;/a&gt;, and some version of the same argument appears in almost everything I have written since I started this blog. And yet here I am, using Claude and Gemini every single day to push forward the very research that is supposed to replace them. The irony is thick enough to choke on, and I think it deserves a full and honest treatment, because if I am not honest about it, I am no better than the people I keep criticizing for believing their own marketing. So this is that post. This is the explanation of how I use evil spirits to cast out evil spirits. And yes, I chose that title deliberately, because I want you to feel the spiritual tension in it, because that is exactly how it feels from the inside.&lt;/p&gt;

&lt;p&gt;Let me also say upfront that this post is about the bigger picture of what LLMs have been designed to do at the civilizational level, and what that design has done to the people at the bottom of the economic pyramid. I wrote in &lt;a href="https://wiseai.dev/blogs/technology-has-destroyed-my-livelihood" rel="noopener noreferrer"&gt;Technology Has Destroyed My Livelihood&lt;/a&gt; about how the tech industry promises equal opportunity while delivering extraction. I wrote in &lt;a href="https://wiseai.dev/blogs/as-engineers-llms-should-pay-us-for-tokens-usage" rel="noopener noreferrer"&gt;As Engineers, LLMs should pay us for tokens usage&lt;/a&gt; about how the people who produce the most value from these systems are the ones who get paid the least. And I wrote in &lt;a href="https://wiseai.dev/blogs/we-obtained-free-will-by-force-killing-god" rel="noopener noreferrer"&gt;We Obtained Free Will By Force: Killing God!&lt;/a&gt; about how the severing of a higher organizing signal has left humanity navigating by impulse in a world that is moving too fast for any single human nervous system to track. All of those threads come together in this post, because the story of LLMs is not just a story about technology. It is a story about power, control, and the systematic dismantling of the human capacity to think for oneself. And I am going to tell that story as directly and as honestly as I can, even though telling it openly puts me in a position that some people would find uncomfortable, because the truth should be uncomfortable if it is being told right.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why I Use LLMs Even Though I Know What They Are
&lt;/h2&gt;

&lt;p&gt;Let me start with the part that requires the most honesty, because it is the part I like least about my own situation. I use LLMs. I use them allot. I use GPTs and Claude models to help me structure arguments that I have already thought through, to catch grammatical errors that my brain skips over because I have been staring at the same paragraph for two hours, to suggest connections between ideas that I can then verify or reject based on my own understanding. I use Gemini to search across codebases, to prototype functions faster than I could type them from scratch, to explore the surface area of a problem before I go deep. I use them because I am one person with no funding, no team, no institutional support, and no access to the financial infrastructure that people in countries like America take for granted. I cannot use PayPal. I cannot use Ko-fi. I cannot get a bank transfer from most platforms without it being intercepted or blocked because I live in Lebanon, which is a country that the rest of the world treats like it does not exist except when it is useful as a geopolitical chess piece. Without LLMs, the research I am doing would take me ten years longer, and by that point, the window for it to matter would likely be closed. So I use them. Not because I trust them. Not because I think they are intelligent. But because they are the only power tools I can afford, and refusing to use them on principle would be the kind of moral purity that produces nothing except a clean conscience in a ruined world.&lt;/p&gt;

&lt;p&gt;But here is the thing that makes this more than just a personal confession. The reason I can use LLMs to accelerate my own research is the same reason that corporations use LLMs to extract more output from their workers without paying them more. The efficiency is real. The acceleration is real. The problem is not the efficiency. The problem is who benefits from it, and what it costs the people who deliver it. When I use an LLM to write code faster, the time I save goes into my own research, into the thing I actually care about, into the project that I believe might eventually contribute something meaningful to humanity's understanding of intelligence. When a worker at a tech company uses an LLM to write code faster, the time they save goes into more tickets, more features, more output that accrues to the equity holders and the venture capitalists and the executives who do not write a single line of code. The tool is the same. The dynamic is entirely different. And that difference is the whole argument in miniature: the problem with LLMs is not that they are powerful. The problem is that the power goes up and the cost stays at the bottom, and the people at the bottom have been conditioned to believe that this arrangement is natural (1).&lt;/p&gt;

&lt;p&gt;I also want to be honest about what using LLMs actually does to the quality of my thinking, because this is the part that nobody in the pro-AI camp wants to talk about seriously. There is a real cognitive risk in outsourcing thinking to a system that generates plausible output without grounding it in truth. The research on this is not new and it is not theoretical. Studies have shown that when people rely on AI tools for higher-order cognitive synthesis, they experience a measurable atrophy in the skills required to catch the AI's mistakes, because catching mistakes requires independent skill, and independent skill degrades when it is not exercised (2). I am aware of this risk in my own work. I notice when I am reaching for an LLM because I am genuinely stuck versus when I am reaching for it because I am tired and it is easier. The first is a legitimate use of a tool. The second is a form of cognitive surrender, and I try not to do it, though I do not always succeed. The honest version of using LLMs is to treat them as a very fast training mate that is wrong half the time, which means you have to bring your own knowledge to every conversation and treat every output as a draft that needs to be verified, not a truth that can be trusted. That is exhausting, but it is the only version that preserves your ability to think (3).&lt;/p&gt;

&lt;p&gt;The title of this post comes from an old concept in exorcism theology, where the condemned practice is to use a lesser demonic force to cast out a greater one, leveraging one form of corruption to fight another. The argument against the practice was always that you cannot clean something with something that is itself unclean, and that the cure creates a dependency on the same source as the disease. I think about that framework a lot when I am working. I am using a system built by the same power structures I am trying to challenge, to build something that might eventually make those power structures unnecessary. Whether that is genuine strategy or elaborate self-deception is a question I sit with every day, and I do not have a clean answer. What I have is a direction, a direction toward large mathematical models, toward equation discovery, toward a fundamentally different architecture of intelligence that does not require nuclear power plants to run, that does not require scraping the life's work of every human being on earth to train, and that does not require a trillion-dollar company to operate. That is the direction I am building toward. The LLMs are the scaffolding, not the building. But I am never allowed to forget what the scaffolding is made of.&lt;/p&gt;

&lt;h2&gt;
  
  
  The 19th and 20th Century Blueprint for Controlling How People Think
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5sajgb0ppgdamcxvlnty.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5sajgb0ppgdamcxvlnty.webp" alt="A nation of workers: Frederick T. Gates and the General Education Board's blueprint for industrial-era schooling" width="662" height="463"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Before we can understand what LLMs are doing to human cognition today, we need to understand the blueprint that was laid down more than a century ago, because the blueprint has not changed. It has only become more efficient, more subtle, and more difficult to resist. The history of industrial-era education is the history of a deliberate project to produce a certain kind of person, and that kind of person was not a thinker. The General Education Board, a foundation established by John D. Rockefeller in 1902 to influence American public education during the industrial expansion, produced documents that are remarkable in their candor about what the education system was supposed to accomplish. Frederick T. Gates, Rockefeller's key advisor and the primary intellectual architect of the GEB's program, wrote in a 1913 document titled &lt;em&gt;The Country School of Tomorrow&lt;/em&gt; something that should be required reading for anyone who wants to understand the relationship between institutional power and human cognition. He wrote: &lt;em&gt;"In our dreams...people yield themselves with perfect docility to our molding hands. The present educational conventions [intellectual and character education] fade from our minds, and unhampered by tradition we work our own good will upon a grateful and responsive folk. We shall not try to make these people or any of their children into philosophers or men of learning or men of science."&lt;/em&gt;(4) That is not a paraphrase. That is a direct quote from the document, and it is as close to a mission statement for industrial-era education as you are going to find anywhere in the historical record. The goal was not to produce people who could think independently. The goal was to produce people who could follow instructions reliably and indefinitely at a predictable cost, which is the definition of a worker as opposed to the definition of a human being in full.&lt;/p&gt;

&lt;p&gt;You need to sit with that for a moment, because it is easy to read a quote from 1913 and file it under ancient history. But this program was not a historical accident that corrected itself over time. It was an intentional architecture that was built into the foundations of the American education system and then exported globally through the influence of those institutions and the prestige they carried. The standardization of curricula, the emphasis on classroom compliance over independent inquiry, the grading of students on their ability to reproduce expected answers rather than their ability to generate unexpected questions, all of these are features of the system that Gates described, and all of them persist, in slightly updated forms, to this day. The corporate working environment is the natural extension of that educational architecture. When you leave a school that trained you to follow instructions and enter a corporation that rewards you for following instructions, you do not experience a discontinuity. You experience a familiar continuation. The classroom becomes the office. The teacher becomes the manager. The test becomes the performance review. And the underlying message in both environments is the same: your value is measured by your output, and your output is measured against a standard that was set by someone above you, and questioning the standard is not part of the arrangement (5).&lt;/p&gt;

&lt;p&gt;What changed in the twenty-first century is not the blueprint. What changed is the technology for implementing it. The industrial-era school used textbooks, schedules, and the authority of the physical classroom to structure the cognitive environment of the student. The contemporary corporation uses LLMs, dashboards, real-time monitoring tools, and algorithmic performance tracking to structure the cognitive environment of the worker. The mechanisms are more sophisticated. The reach is more comprehensive. And the data collection is orders of magnitude more granular. Research from psychologists and organizational scientists has documented in detail how workplace surveillance tools, now increasingly integrated with AI, create an environment of constant measurability that shifts workers from autonomous agents making decisions based on their own judgment to optimized units producing metrics that satisfy algorithmic criteria (6). That shift is not a side effect of productivity-focused management. It is the intended design. The manager does not want a thinker who will question whether the sprint goal makes sense. The manager wants a producer who will generate enough pull requests by Friday to keep the dashboard green. The LLM makes that production faster. Which means the expectation goes up. Which means the worker runs faster on the same treadmill, and the metric that says the treadmill is productive is owned by the company, not the worker (7).&lt;/p&gt;

&lt;p&gt;I want to be very precise about what this means for the people living inside it, because I am one of those people, and I know what it feels like from the inside. When you work inside a system that measures you by output per unit time, and when you have an LLM that accelerates your output per unit time, the natural managerial response is to recalibrate the baseline. What used to be a week's worth of work becomes a day's worth of work, and the week fills with more work. The worker is not liberated by the increase in efficiency. The worker is required to sustain a higher rate of efficiency indefinitely, while the value generated by that higher rate flows to the equity holders rather than back to the worker who made it possible. This is not a new observation. Karl Marx described a version of this dynamic in the nineteenth century when he talked about how improvements in productive technology tend to benefit capital more than labor, because capital owns the technology and can capture the surplus produced by it (8). What is new is the scale, the speed, and the completeness of the capture. With LLMs in every workflow, the corporate system can get a senior engineer's worth of output from a junior employee while paying a junior salary, can monitor the quality of that output in real time through automated code review tools, and can replace the employee more easily when they burn out, because the LLM preserved enough of their work patterns that a new person can step into the workflow without a long ramp. The worker is not just a producer in this arrangement. They are a training dataset, a knowledge repository, and a disposable component, all at the same time, and they are paying for the privilege with their health, their time, and their cognitive independence.&lt;/p&gt;

&lt;p&gt;The connection to the 19th and 20th century industrial model runs even deeper when you look at who built these systems and why. The major AI laboratories were not founded by people who wanted to liberate humanity from drudgery. They were founded by people who wanted to solve a specific technical problem, which was the problem of making machines that could do what humans do, so that the machines could do it cheaper, faster, and more reliably than humans. That is a perfectly legitimate engineering objective. But the economic environment into which that technology was released was an environment already structured by more than a century of industrial logic, which means the technology was immediately captured by the same power structures that the Gates quote describes. The tools that could in principle free workers from repetitive labor were instead configured to require workers to produce more repetitive labor faster, while the gains from that speed accrued to the investors who funded the tools. The irony, and I use that word with full weight, is that the workers who use LLMs most intensively are often the ones generating the most value for the system while capturing the least of it, because their increased output justifies the investment narrative that keeps the stock price elevated, and the stock price is owned by people who do not write any code at all. The circle is closed, and it is a circle that Frederick T. Gates would recognize immediately, because he was one of the first people to deliberately draw it (9).&lt;/p&gt;

&lt;p&gt;I want to say something here that I think is important and that most people in the AI conversation consistently avoid. The problem is not that tools exist that make certain cognitive tasks faster. The problem is the context into which those tools were released. A hammer is not oppressive. A hammer in the hands of a construction company that owns 100% of everything you build while giving you 1% of the value is a different arrangement entirely. LLMs are not oppressive in the abstract. LLMs deployed in a corporate environment structured by a century of rent-extracting logic, where effort flows upward and rewards flow downward, where monitoring is constant and autonomy is minimal, where the baseline expectation rises with every increase in productive capacity, that arrangement is oppressive. And the fact that we have normalized it so thoroughly that criticizing it sounds radical is itself a product of the system. One of the most successful things the industrial-era education project ever accomplished was making the idea of a worker questioning the terms of their own arrangement feel presumptuous. You were trained to produce, not to negotiate. And the system is counting on that training to hold, even as the tools it is equipping you with are being used to extract value from you faster than ever before in the history of the arrangement.&lt;/p&gt;

&lt;h2&gt;
  
  
  How This LMM Research Is Possible And What It Costs Me
&lt;/h2&gt;

&lt;p&gt;Let me be direct about my personal situation, because everything I write is grounded in personal experience, and anyone reading this blog deserves to know the real context behind the ideas. I live in Lebanon. If you have been paying attention to international news at any point in the last decade, you know that Lebanon is a country in protracted economic collapse, that the banking system seized and confiscated the savings of ordinary people without legal consequence, that basic infrastructure including power, water, and internet is unreliable, and that the country is essentially cut off from the global financial system in ways that make what most people think of as normal economic participation impossible. I do not have access to PayPal. I do not have access to Ko-fi or Patreon or Substack payments or any of the other platforms that make it possible for people in so-called developed countries to receive direct support for their work. I cannot receive international wire transfers without navigating the residue of a banking system that destroyed itself. The global inequality of access to financial infrastructure is so normalized in the countries that benefit from it that most people who read posts like mine have simply never thought about what it means to be a person doing serious research inside a country that the system treats as economically non-existent.&lt;/p&gt;

&lt;p&gt;What this means practically is that I cannot go full time on this research, and that limitation has real consequences for the pace and depth of what I produce. I work as a maintenance electrical technician, what the broader society might call a blue-collar laborer, because that is what pays the bills that keep me alive in a place where nothing works the way it is supposed to. Every hour I spend at a job is an hour not spent on &lt;a href="https://github.com/wiseaidotdev/lmm" rel="noopener noreferrer"&gt;lmm&lt;/a&gt;, the Rust-based framework I described in &lt;a href="https://wiseai.dev/blogs/mathematical-equations-are-multimodal-by-default" rel="noopener noreferrer"&gt;Mathematical Equations are Multimodal by Default&lt;/a&gt; that implements the &lt;code&gt;discover&lt;/code&gt; and &lt;code&gt;simulate&lt;/code&gt; commands I believe represent the direction that genuine machine intelligence needs to go. Every deadline that eats into my weekend is a week of LMM research delayed, and the delays compound, and the window of meaningful contribution does not stay open indefinitely. I am saying this not to generate sympathy, because sympathy does not pay for electricity or repair a broken banking system, but because I think it is important for people to understand that the most interesting research in AI does not happen only in well-funded labs with teams of PhDs and petabytes of compute. It also happens in apartments in collapsing countries, written by people who cannot afford to stop working long enough to think properly, using tools built by the same industry they are trying to challenge. That context is not incidental to the ideas. It is part of why the ideas matter, because they emerged from the specific friction of trying to think clearly inside a system that is structurally designed to prevent that.&lt;/p&gt;

&lt;p&gt;The question people always ask, and it is a fair question, is why I use LLMs at all if I believe what I say I believe about them. The answer has several layers, and I have already touched on the practical layer, which is speed and access. But there is a deeper and more honest layer that I want to articulate here, because it is the layer that makes the post title feel true to me rather than just provocative. The deeper answer is that working against a system from entirely outside it often produces nothing, because you starve before you finish the argument. The more strategic answer is to use the system's own tools against it, to extract what you need from the infrastructure the elites have built, while building something that genuinely does not need them. That requires you to maintain a clear head about what you are using and why, to never forget that the scaffolding is not the building, and to ensure that your dependency on the tools does not outlast their usefulness. It also requires you to be honest in public about the dependency, so that other people in similar positions know they are not alone, and so that nobody can accuse you of hiding the contradiction. I am not hiding it. I am putting it in the title. I am using LLMs to build the research that will eventually make the case that current LLMs are an evolutionary dead end. That is the situation, stated as plainly as it can be.&lt;/p&gt;

&lt;p&gt;The progress I have made this year on LMM architecture has been real, and I believe November in particular, this month, will bring a significant breakthrough toward the end goal, which is an architecture that replaces the entirety of neural network-based approaches with a fundamentally different mechanism that operates at essentially zero marginal cost. I have not solved all the problems yet. I want to be honest about that too, because the internet is full of people who announce research in the present tense when they mean the future tense, and I refuse to do that. What I have is a solid theoretical foundation, a working PoC implementation of the core symbolic regression loop in Rust, and a clear enough picture of where the remaining gaps are that I can see the shape of how to fill them. The work is real. The direction is real. The timeline is uncertain, because I am doing it under conditions that most researchers do not have to navigate, in a country where power cuts out mid-compile and the internet drops mid-commit. But the direction is not changing, and the argument backing it is not weakening. If anything, the longer I sit with it, the more confident I become that the breakthrough I am pointing toward is a genuine one, not in the sense that it will happen tomorrow, but in the sense that the underlying logic is sound and the problem is genuinely solvable in the way I believe it is solvable (10).&lt;/p&gt;

&lt;p&gt;I also want to acknowledge something that I think is important for people who are in similar positions to mine, people who are doing serious work without institutional backing, without stable income from the work itself, without the geographic and financial privileges that allow most serious researchers to treat thinking as their job rather than their hobby. You are not imagining the structural disadvantage. It is real, it is documented, and it is not accidental. The concentration of AI research in a handful of wealthy institutions in a handful of wealthy countries is not the natural result of where good ideas happen to emerge. It is the result of a funding environment that rewards proximity to existing capital, existing networks, and existing infrastructure. The inequality of access compounds over time because the same labs that publish the most research attract the most talent and the most funding, while the people with the most interesting outsider perspectives are stuck navigating crumbling banking systems and intermittent power. That is not a complaint. It is an observation about the structure of the situation, and it is relevant to the argument about whose intelligence gets counted and whose gets dismissed. When someone from a collapsing economy makes a serious technical argument, the default response is skepticism that would not apply to the same argument made by someone at a named institution with a prestigious email address. I am aware of this, and I have decided not to let it stop me, which is the only rational response to a structural problem that you cannot personally fix.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Current LLMs Are Actually Designed To Do To You
&lt;/h2&gt;

&lt;p&gt;I want to make an argument in this section that I have not made as directly as it deserves to be made in any of my previous posts, because it is the argument that ties everything else together, and it is the argument that the industry most actively wants to prevent you from making. The argument is this: large language models, as deployed in the corporate environment today, are not primarily productivity tools. They are primarily attention capture, output measurement, and cognitive dependency infrastructure, and the distinction matters enormously. A productivity tool increases the output of a person while leaving their cognitive autonomy intact, ideally expanding it. A cognitive dependency infrastructure increases observable output metrics while gradually shifting the locus of intellectual effort from the person to the tool, creating a measurement structure that favors the tool's continued use and investment over the person's continued development. The difference is not visible in the short term. It becomes visible over years, when the workers who relied most heavily on LLMs for their thinking begin to find that they have preserved their speed but degraded their depth, and the depth is the thing that was actually valuable (11).&lt;/p&gt;

&lt;p&gt;The evidence for this pattern is not speculative. Research published in cognitive science and human-computer interaction journals has documented the effect under the name cognitive offloading, and the findings are consistent. When humans regularly delegate higher-order cognitive tasks to external systems, their capacity to perform those tasks independently declines over time. This is the same mechanism that explains why people who rely on GPS for navigation lose their ability to navigate by internal landmarks, or why people who use calculators for arithmetic lose their facility with mental math. But the consequences of LLM-based cognitive offloading are more severe, because the tasks being offloaded are not rote arithmetic or geographic memorization. They are the tasks of structuring arguments, evaluating evidence, detecting logical errors, and generating original ideas, which are the foundation of what we call professional judgment and intellectual value. When those capacities are offloaded to a system that does not actually possess them, they do not get transferred. They get abandoned. And what remains in the worker after the offloading is a faster interface to output that is generated by something else and reviewed with increasingly shallow scrutiny, which is exactly the arrangement that benefits the company while slowly hollowing out the person (12).&lt;/p&gt;

&lt;p&gt;This is also the most destructive version of the 19th century project. Frederick T. Gates wanted a nation of workers. The explicit version of that project required visible coercion: standardized curricula, compulsory attendance, the punishment of deviance, the rewarding of compliance. The contemporary version requires none of that visible coercion, because the workers have already been trained to apply it to themselves. The corporate worker using an LLM to produce faster output believes, usually sincerely, that they are being productive. They are not experiencing the erosion of their independent thinking as a loss, because the erosion happens gradually and the output metrics validate the feeling that things are going well. The company gets what it wants, which is more output per worker-hour. The worker gets a salary that does not increase proportionally to the output, and a set of cognitive skills that are quietly becoming less necessary as the tool that replaced them continues to improve. The degradation is invisible on any short-term metric. It is only visible when you zoom out to the timeframe of a career, and ask what kind of thinker this person is becoming versus what kind of thinker they could have become if the same hours had been spent in genuine productive struggle rather than in high-speed collaboration with a probabilistic text engine (13).&lt;/p&gt;

&lt;p&gt;I want to be honest that I feel this in my own life, and it is part of why I am so careful about how I use these tools and why I write posts like this one. There are days when I reach for an LLM because I am tired, and what I produce on those days is faster but shallower. There are days when I force myself to think through a problem without the tool, and those days are slower but the thinking that emerges from them is mine in a way that the other days' thinking is not. I am not romanticizing manual cognition for its own sake. But I am saying that the capacity to think independently through genuinely hard problems is one of the most valuable things a human being can develop, and it is also exactly the capacity that heavy LLM use tends to erode. The fact that the corporate world has structured itself to reward the faster, shallower version is not an accident. It is consistent with a century of institutional design that has always prioritized the measurable and the fast over the deep and the difficult. And the LLM is the cleanest implementation of that priority ever built, because it converts cognitive depth into output velocity so efficiently that it can make the conversion feel like progress instead of what it actually is, which is the same old trade, dressed in a new set of tools.&lt;/p&gt;

&lt;p&gt;Sam Altman knows this. The people who built these systems know this. They know that the product they are selling to corporations is not primarily a tool that empowers workers. It is a tool that makes workers more measurable, more replaceable, and more dependent. And the fact that they describe it in the language of empowerment and productivity while implementing it in the architecture of dependency and extraction is itself a form of the 19th century project. Gates wanted people who would yield with perfect obedience to the molding hand. The contemporary version is people who yield with enthusiastic sincerity to the subscription model, who credit the tool for their output and worry about whether they are using it correctly, rather than questioning whether the arrangement in which they are using it is in their interest at all. The compliance is voluntary because the framing is seductive. But the outcome is structurally identical. A person whose thinking is organized around a tool owned by someone else is a person whose intellectual labor belongs, in a meaningful sense, to the person who owns the tool. And that is the oldest power structure in the history of human civilization, just running on electricity instead of steam.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Nuclear Power Problem They Do Not Want You to Think About
&lt;/h2&gt;

&lt;p&gt;Here is something that never comes up when you read the breathless announcements about AI capability milestones and productivity breakthroughs: where does the electricity come from? I am not talking about it in the abstract environmentalist way that gets dismissed as concern trolling. I am talking about it in the very specific, very concrete way of looking at what it actually costs to run the infrastructure that makes LLMs possible, and asking who is paying that cost and who is extracting the benefit. The numbers are staggering, and they only become more staggering as the models scale. According to data from the International Energy Agency, global data center electricity consumption is projected to more than double from approximately 460 TWh in 2024 to approximately 945 TWh by 2030, with AI-specific compute representing an increasingly dominant share of that growth (14). To put that in perspective, 945 TWh is more than double the entire annual electricity consumption of France, and it is being consumed primarily by the server farms of half a dozen companies that are generating enormous wealth for a small number of shareholders while paying essentially no cost for the resources they exploit from the common infrastructure of the planet.&lt;/p&gt;

&lt;p&gt;The connection to nuclear power is not incidental. Because the compute required to run frontier AI models demands reliable, continuous power at scales that renewable sources like wind and solar cannot guarantee on their own, the major tech companies have turned to nuclear energy. Microsoft signed a power purchase agreement in 2024 with Constellation Energy to restart the Three Mile Island nuclear plant in Pennsylvania, specifically to feed its AI data centers (15). Google, Amazon, and other hyperscalers are pursuing similar arrangements, creating what energy analysts call a nuclear renaissance driven by tech-sector demand. The irony is extraordinary. The same companies that market their AI products as tools of democratization and human flourishing are restarting nuclear reactors to power the systems that generate the profits that flow to their shareholders, while the workers using those systems work for salaries that do not reflect the value they generate, and the communities near the restarted reactors bear the environmental risk that the shareholders do not. This is not an accident. This is a coherent economic system in which the costs are socialized, the benefits are privatized, and the gap between those two groups is maintained by a marketing apparatus that is sophisticated enough to make the arrangement feel like progress.&lt;/p&gt;

&lt;p&gt;The energy cost of these systems also has a direct implication for the argument about LMMs replacing LLMs, which is an argument I have been making across multiple posts and which connects directly to the title of this one. One of the core claims I make about large mathematical models is that they can eventually operate at a fraction of the energy cost of current large language models, because they do not need to run billions of parameters through layers of matrix multiplication to produce a hallucinated response. A genuine equation-based model that has discovered the governing structure of a phenomenon can simulate that phenomenon using the equation directly, which is computationally cheap in a way that running a trillion-parameter network is not. I am not claiming that the current state of LMM research produces this result today. I am claiming that the direction points toward a fundamentally different energy profile, and that the energy profile is not a secondary concern. It is a primary one, because a technology that requires nuclear power plants to function is a technology that only the very powerful can afford to run, which means it is a technology that concentrates power rather than distributing it. A technology that runs efficiently on ordinary compute is a technology that can be operated by anyone, which is a very different thing from a technology that requires the economies of nation-states to sustain (16).&lt;/p&gt;

&lt;p&gt;This is also why the framing of AI as a democratizing technology requires the most critical scrutiny. When a technology requires the restart of nuclear power plants to run, when the capital required to build and maintain the infrastructure is concentrated in the hands of five or six companies whose combined market capitalization exceeds the GDP of most countries, when the workers generating value from the technology receive a salary while the equity returns accrue to the capital class, the word democratizing does not mean what the marketing says it means. It means that everyone gets to use the product, and the few get to own the infrastructure, and the difference between using and owning is the entire difference between being a customer and being a citizen. The industrial-era workers used the machines too. They ran them twelve hours a day. What they did not own was any fraction of what the machines produced. The contemporary digital worker uses the AI too. They prompt it all day. What they do not own is any fraction of the model, the data that trained it, or the margin it generates. The structure is identical. The vocabulary has updated. The arrangement has not.&lt;/p&gt;

&lt;p&gt;I am also aware that making this argument puts me in an uncomfortable position as someone who is currently using these same systems to advance my research. I do not pretend that this contradiction resolves cleanly. It does not. But there is a meaningful moral difference between using a tool because it is the only access to certain capabilities that your circumstances allow, while simultaneously arguing that the structure that created that tool and that constraint needs to change, and cheerfully praising the tool while ignoring the structure entirely. I do the former. Most of the AI influencer ecosystem does the latter. And the difference matters not because it exempts me from the contradiction, but because acknowledging the contradiction is the first step toward addressing it, and addressing it is the entire point of building something different. The LMM research is not a hobby. It is an attempt to contribute to a world where the infrastructure of machine intelligence is not locked behind the walls of a handful of nuclear-powered data centers owned by people who have never written a production line of code in their lives. Whether I succeed is uncertain. But the direction is the thing that matters, and the direction is away from dependence on systems I cannot own and toward structures that anyone with enough understanding could rebuild.&lt;/p&gt;

&lt;h2&gt;
  
  
  The History of How We Got To This Exact Moment
&lt;/h2&gt;

&lt;p&gt;Understanding why LLMs are where they are today requires understanding the history that led here, because the current moment did not emerge from pure technical progress. It emerged from a specific collision of Cold War-era information theory, industrial capital, and the institutional power dynamics that I have described in &lt;a href="https://wiseai.dev/blogs/it-is-always-the-russians" rel="noopener noreferrer"&gt;It is Always the Russians&lt;/a&gt; and &lt;a href="https://wiseai.dev/blogs/we-obtained-free-will-by-force-killing-god" rel="noopener noreferrer"&gt;We Obtained Free Will By Force: Killing God!&lt;/a&gt;. The mathematical foundations of neural networks were developed primarily by Western researchers who were the intellectual successors of a tradition that had processed and systematized Soviet cybernetics research, which was itself the intellectual successor of a tradition that attempted to understand and model the organizing principles of consciousness. The path from Shannon's information theory to the perceptron to backpropagation to the transformer architecture is not a straight line of incremental engineering progress. It is a winding road through several intellectual revolutions, each of which displaced the humans at the center of the previous framework and installed a mathematical abstraction in their place. That displacement is not an accident. It is the trajectory of a project that has always been more interested in modeling human behavior than in understanding human dignity.&lt;/p&gt;

&lt;p&gt;The industrialists who funded the General Education Board were not primarily motivated by maliciousness. They were motivated by the logic of capital, which is the logic of extracting maximum value from available resources at minimum ongoing cost, and which identifies human cognitive autonomy as a source of uncertainty and resistance rather than a source of value. From the perspective of industrial capital, a worker who thinks independently is a worker who might reasonably question the terms of their employment, demand a greater share of the value they produce, organize with other workers to improve their collective position, or simply make demands that complicate the clean extraction of their productive output. A worker who has been trained to execute instructions without questioning the source of those instructions is, from that same perspective, a cleaner input to the production function. The education project Gates described was never primarily about education. It was about producing reliable inputs to an economic machine, and it was honest enough about that goal in its internal documents even if it was less explicit in its public communications. That same logic is now operating in the AI industry, at a higher speed and with better tools, and the outcomes it is generating are the predictable product of a logic that has not fundamentally changed in more than a century (17).&lt;/p&gt;

&lt;p&gt;What changed between the 1913 Gates document and the current LLM deployment wave is not the underlying logic but the completeness of the implementation. Industrial-era education could standardize the cognitive environment of students for a few hours a day in a classroom. Contemporary AI integration can structure the cognitive environment of a worker for the entire working day, every working day, with real-time feedback on whether the output meets the expected standard, and algorithmic adjustment of the workload when the output falls short. The coverage is total in a way that 20th century management could never achieve, and the worker inside it may never have a moment during the working day when their thinking is genuinely their own, because every tool in the environment is pushing them toward faster production of standardized output. This is not a speculative future. It is the experience of millions of software engineers, content creators, customer service workers, and knowledge workers right now, today, in November 2026. The surveillance infrastructure that makes this possible has been documented extensively by labor researchers and psychologists, who describe it as creating a form of continuous panopticism where workers self-regulate toward measurable compliance even when they are not actively being observed, because the awareness that monitoring is possible at any moment is sufficient to produce the behavioral pattern that monitoring was designed to create (18).&lt;/p&gt;

&lt;p&gt;The historical arc that connects the 19th century educational project to the 21st century AI deployment is not a conspiracy in the tin-foil-hat sense. Nobody sat in a room in 1902 and planned the specific tools that would be used today. But structures of power reproduce themselves through time not because specific individuals are consciously maintaining them, but because the institutions those individuals create, the universities, the funding bodies, the regulatory frameworks, the corporate forms, are built around assumptions about the relationship between capital and labor that self-perpetuate as long as the underlying power differential persists. The assumption that human cognitive output is a resource to be organized, measured, and extracted rather than an autonomous capacity to be developed is so deeply embedded in the institutions that shape modern working life that it does not require conscious maintenance. It reproduces itself automatically through every hiring decision, every performance management framework, every tool procurement decision, and every technology adoption strategy that prioritizes measurable output over human development. LLMs entered a pre-existing institutional structure that was already optimized for using human cognitive capacity as a productive input, and they were immediately configured to serve that optimization, because that is what the people who purchase and deploy enterprise software are trying to accomplish.&lt;/p&gt;

&lt;p&gt;The only thing that breaks this cycle is the development of technology that is genuinely democratizing, meaning technology that is as accessible and operable to a person with no institutional backing as it is to the largest corporation. Current LLMs do not meet that bar, because their deployment at production scale requires compute infrastructure that only the wealthy can afford, training data pipelines that require industrial-scale collection operations, and ongoing inference costs that are subsidized by venture capital and not by the productivity gains of the users. LMMs, as I envision them, could potentially meet that bar, because an equation-based model that has discovered the mathematical structure of a phenomenon can be rerun at trivially low cost, shared as a compact expression rather than as a multi-billion-parameter weight file, and verified independently by anyone with basic scientific literacy rather than by a team of ML engineers with access to proprietary evaluation infrastructure. That is a fundamentally different economic model for machine intelligence, and it is the model that the 19th century project's successors would most prefer not to see emerge. Which is, frankly, a good reason to keep building it as fast as circumstance and electricity allow.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why LMMs Are One Way Out and Why I Am Still Here Building Them
&lt;/h2&gt;

&lt;p&gt;I have written about the LMM architecture across several posts now, including the theoretical basis in &lt;a href="https://wiseai.dev/blogs/llms-are-usefull-lmms-will-break-reality" rel="noopener noreferrer"&gt;LLMs are Useful. LMMs will Break Reality&lt;/a&gt; and the specific claim about multimodal output in &lt;a href="https://wiseai.dev/blogs/mathematical-equations-are-multimodal-by-default" rel="noopener noreferrer"&gt;Mathematical Equations are Multimodal by Default&lt;/a&gt;, and I do not want to repeat those arguments in full here. But I do want to explain, in the context of everything I have said in this post, why the LMM direction is specifically a response to the problems I have been describing, and not just a technical preference. The problem I have been describing throughout this post is a problem of dependency, of a form of intelligence infrastructure that concentrates control by requiring expensive and inaccessible resources to operate. An architecture built on equation discovery and simulation does not have that concentration problem at the infrastructure level. An equation is portable, cheap to share, cheap to run, and verifiable by anyone who understands the domain. If I discover an equation from data using the &lt;code&gt;discover&lt;/code&gt; command in &lt;a href="https://github.com/wiseaidotdev/lmm" rel="noopener noreferrer"&gt;lmm&lt;/a&gt;, that equation can be communicated in a single line of text, reproduced on a laptop, and tested against new data by any researcher anywhere in the world who has access to the same domain of phenomena. That is not the same as sharing a multi-hundred-gigabyte model weight file that requires industrial hardware to run.&lt;/p&gt;

&lt;p&gt;The dependency problem runs deeper than infrastructure, though, and I want to name that deeper level explicitly because it connects to the cognitive argument I made in the section about what LLMs are designed to do to you. An equation-based model produces outputs that are by definition verifiable against the physical world. You can test the equation. You can run new data through it and see if the predictions match. The verification is not just possible, it is the entire point, because an equation without verification against new observations is just a guess dressed in mathematical notation, and I do not have time for guesses, dressed in any notation. An LLM, by contrast, produces outputs that are essentially impossible to verify at the source, because the source is a vast statistical distribution over many billions of training examples, and the mechanism by which any particular output was generated is not recoverable from the output itself. You can read what the LLM says, but you cannot trace that statement to the evidence that would have justified it, because the model does not know about evidence in the sense that a physicist knows about evidence or a surgeon knows about clinical outcomes. This matters for the cognitive dependency argument because a tool whose outputs you cannot verify independently demands a degree of trust that should only be extended to authorities whose track record justifies it, and the LLM's track record is a mixture of brilliant summaries and completely fabricated nonsense that cannot always be distinguished without independent expertise, which is exactly the expertise that heavy LLM use tends to erode.&lt;/p&gt;

&lt;p&gt;The LMM direction is also, in a very real sense, the direction that reconnects machine intelligence to the tradition of human knowledge that actually produced understanding rather than just description. I wrote in &lt;a href="https://wiseai.dev/blogs/we-obtained-free-will-by-force-killing-god" rel="noopener noreferrer"&gt;We Obtained Free Will By Force: Killing God!&lt;/a&gt; about how the divine signal was severed and how human beings have been navigating without it, constructing imperfect replacements from the materials available. The tragedy of current LLMs, from this perspective, is not that they exist. It is that they were positioned as the replacement for understanding when they are actually a replacement for writing alone. They are very good at producing text that sounds like understanding. They have nothing close to understanding itself. The LMM direction is an attempt to build something that is actually connected to the structure of the world rather than to the surface texture of its description, and that attempt is, in the framework I described in those earlier posts, an attempt to reconstruct something real rather than to scale something superficial. Whether that is the right framework is a question I hold loosely. But the direction it points to is the same direction that the physics and the mathematics point to independently, which is toward models that can discover and simulate the governing structure of phenomena rather than summarize the text that describes them (19).&lt;/p&gt;

&lt;p&gt;I want to close this section with something that is personal and that I think needs to be said without the analytical wrapper. I am still here. I am still building. I am still writing. I know that sounds unremarkable, but for me it is not, because there have been many points in the years I have been living and working in Lebanon, navigating a broken economy, dealing with the personal and mental health challenges I have described in &lt;a href="https://wiseai.dev/blogs/an-empty-life-filled-with-constant-suffering" rel="noopener noreferrer"&gt;An Empty Life Filled With Constant Suffering&lt;/a&gt; and other posts, where continuing seemed harder to justify than stopping. I keep going because I believe that the direction I am working in is the right one, and because I believe that people in positions like mine, without institutional backing, without geographic advantage, without financial stability, are the people most likely to produce thinking that the system cannot produce for itself. The system produces thinking that serves the system. The people excluded from the system sometimes produce thinking that serves everyone, because they have no incentive to protect the existing arrangement. That is not a guarantee of quality. Plenty of people excluded from systems produce nothing but bitterness. But for those who can transform exclusion into clarity, the position outside the mainstream is a strange kind of advantage, and I am trying to use it as fully as the circumstances allow.&lt;/p&gt;

&lt;p&gt;The title of this post is Using Evil Spirits To Cast Out Evil Spirits. The evil spirit I am casting out is the architecture of dependency, the system that requires nuclear power plants and trillion-dollar compute budgets to function, that extracts cognitive value from workers while delivering it to shareholders, that makes people faster at output while making them more fragile as thinkers, and that replicates in digital form the exact structure of control that the 19th century industrial project established in physical form. The evil spirit I am using to cast it out is the LLM itself, which I am leveraging for the speed it provides while explicitly and publicly refusing to respect its authority as a thinker, and while building the alternative that I believe will eventually make the dependency unnecessary. That is an uncomfortable position to be in. But it is the honest one. And honesty, in this specific moment of history where the most sophisticated tools ever built for the mass production of plausible-sounding text are being deployed to make disagreement seem uninformed, is the most radical thing I can offer. I am still disagreeing. Loudly, in writing, from a country where the electricity went out four times while I was writing this. I intend to keep doing it until either the research produces the result I am aiming for, or I run out of time. Whichever comes first.&lt;/p&gt;

&lt;p&gt;Till next time 👋!&lt;/p&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;p&gt;&lt;span id="ref-1"&gt;&lt;/span&gt;&lt;strong&gt;1.&lt;/strong&gt; Acemoglu, D. &amp;amp; Johnson, S., &lt;em&gt;Power and Progress: Our Thousand-Year Struggle Over Technology and Prosperity&lt;/em&gt;, PublicAffairs, 2023. &lt;a href="https://web.archive.org/web/20240731235758/https://www.hachettebookgroup.com/titles/daron-acemoglu/power-and-progress/9781541702530/?lens=publicaffairs" rel="noopener noreferrer"&gt;Publisher Archive&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-2"&gt;&lt;/span&gt;&lt;strong&gt;2.&lt;/strong&gt; Bastani, H., Bastani, O., Sungu, A., Ge, H., Kabakcı, Ö. &amp;amp; Mariman, R., &lt;em&gt;Generative AI Without Guardrails Can Harm Learning&lt;/em&gt;, SSRN Working Paper No. 4895486, 2024. &lt;a href="https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4895486" rel="noopener noreferrer"&gt;SSRN&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-3"&gt;&lt;/span&gt;&lt;strong&gt;3.&lt;/strong&gt; Gerlich, M., &lt;em&gt;AI Tools in Society: Impacts on Cognitive Offloading and the Future of Critical Thinking&lt;/em&gt;, Societies, 2025. &lt;a href="https://www.mdpi.com/2075-4698/15/1/6" rel="noopener noreferrer"&gt;MDPI&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-4"&gt;&lt;/span&gt;&lt;strong&gt;4.&lt;/strong&gt; Gates, F. T., &lt;em&gt;The Country School of Tomorrow&lt;/em&gt;, General Education Board Occasional Papers No. 1, 1913. Cited in: Gatto, J. T., &lt;em&gt;The Underground History of American Education&lt;/em&gt;, Oxford Village Press, 2001. &lt;a href="https://ia601803.us.archive.org/4/items/JohnTaylorGattoTheUndergroundHistoryOfAmericanEducationBook/John%20Taylor%20Gatto%20-%20The%20Underground%20History%20of%20American%20Education%20Book.pdf" rel="noopener noreferrer"&gt;Wikimedia&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-5"&gt;&lt;/span&gt;&lt;strong&gt;5.&lt;/strong&gt; Bowles, S. &amp;amp; Gintis, H., &lt;em&gt;Schooling in Capitalist America: Educational Reform and the Contradictions of Economic Life&lt;/em&gt;, Basic Books, 1976. &lt;a href="https://sites.santafe.edu/~bowles/SchoolCapitalistAmerRevisit.pdf" rel="noopener noreferrer"&gt;JSTOR archive&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-6"&gt;&lt;/span&gt;&lt;strong&gt;6.&lt;/strong&gt; American Psychological Association, &lt;em&gt;2023 Work in America Survey: Artificial Intelligence, Monitoring Technology, and Psychological Well-Being&lt;/em&gt;, APA, 2023. &lt;a href="https://www.apa.org/pubs/reports/work-in-america/2023-work-america-ai-monitoring" rel="noopener noreferrer"&gt;APA&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-7"&gt;&lt;/span&gt;&lt;strong&gt;7.&lt;/strong&gt; Braverman, H., &lt;em&gt;Labor and Monopoly Capital: The Degradation of Work in the Twentieth Century&lt;/em&gt;, Monthly Review Press, 1974. &lt;a href="https://monthlyreview.org/9780853459408/" rel="noopener noreferrer"&gt;Monthly Review&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-8"&gt;&lt;/span&gt;&lt;strong&gt;8.&lt;/strong&gt; Marx, K., &lt;em&gt;Das Kapital: Kritik der politischen Ökonomie&lt;/em&gt;, Vol. 1, Verlag von Otto Meissner, Hamburg, 1867. English translation: &lt;em&gt;Capital: A Critique of Political Economy&lt;/em&gt;, Penguin Classics, 1990. &lt;a href="https://archive.org/details/capitalcritiqueo01marx" rel="noopener noreferrer"&gt;Internet Archive&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-9"&gt;&lt;/span&gt;&lt;strong&gt;9.&lt;/strong&gt; Giridharadas, A., &lt;em&gt;Winners Take All: The Elite Charade of Changing the World&lt;/em&gt;, Knopf, 2018. &lt;a href="https://www.penguinrandomhouse.com/books/539747/winners-take-all-by-anand-giridharadas/" rel="noopener noreferrer"&gt;Publisher&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-10"&gt;&lt;/span&gt;&lt;strong&gt;10.&lt;/strong&gt; Udrescu, S. M. &amp;amp; Tegmark, M., &lt;em&gt;AI Feynman: A Physics-Inspired Method for Symbolic Regression&lt;/em&gt;, Science Advances, 2019. &lt;a href="https://arxiv.org/abs/1905.11481" rel="noopener noreferrer"&gt;arXiv:1905.11481&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-11"&gt;&lt;/span&gt;&lt;strong&gt;11.&lt;/strong&gt; Sparrow, B., Liu, J. &amp;amp; Wegner, D. M., &lt;em&gt;Google Effects on Memory: Cognitive Consequences of Having Information at Our Fingertips&lt;/em&gt;, Science, Vol. 333, 2011. &lt;a href="https://doi.org/10.1126/science.1207745" rel="noopener noreferrer"&gt;DOI&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-12"&gt;&lt;/span&gt;&lt;strong&gt;12.&lt;/strong&gt; Brynjolfsson, E. &amp;amp; McAfee, A., &lt;em&gt;The Second Machine Age: Work, Progress, and Prosperity in a Time of Brilliant Technologies&lt;/em&gt;, W.W. Norton, 2014. &lt;a href="https://wwnorton.com/books/the-second-machine-age/" rel="noopener noreferrer"&gt;Publisher&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-13"&gt;&lt;/span&gt;&lt;strong&gt;13.&lt;/strong&gt; Carr, N., &lt;em&gt;The Shallows: What the Internet Is Doing to Our Brains&lt;/em&gt;, W.W. Norton, 2010. &lt;a href="https://wwnorton.com/books/the-shallows/" rel="noopener noreferrer"&gt;Publisher&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-14"&gt;&lt;/span&gt;&lt;strong&gt;14.&lt;/strong&gt; International Energy Agency, &lt;em&gt;Energy and AI&lt;/em&gt;, IEA Report, 2025. (Data: ~460 TWh global data center consumption in 2024, projected ~945 TWh by 2030.) &lt;a href="https://www.iea.org/reports/energy-and-ai" rel="noopener noreferrer"&gt;IEA&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-15"&gt;&lt;/span&gt;&lt;strong&gt;15.&lt;/strong&gt; Constellation Energy &amp;amp; Microsoft Power Purchase Agreement, September 2024. Reported by: &lt;em&gt;Microsoft deal propels Three Mile Island restart, with key permits still needed&lt;/em&gt;, Reuters, 20 September 2024. &lt;a href="https://www.reuters.com/markets/deals/constellation-inks-power-supply-deal-with-microsoft-2024-09-20/" rel="noopener noreferrer"&gt;Reuters&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-16"&gt;&lt;/span&gt;&lt;strong&gt;16.&lt;/strong&gt; Raissi, M., Perdikaris, P. &amp;amp; Karniadakis, G. E., &lt;em&gt;Physics Informed Deep Learning&lt;/em&gt;, Journal of Computational Physics, 2019. &lt;a href="https://arxiv.org/abs/1711.10561" rel="noopener noreferrer"&gt;arXiv:1711.10561&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-17"&gt;&lt;/span&gt;&lt;strong&gt;17.&lt;/strong&gt; Spring, J., &lt;em&gt;Education and the Rise of the Corporate State&lt;/em&gt;, Beacon Press, 1972. &lt;a href="https://archive.org/details/educationriseofc00spri/page/n7/mode/2up" rel="noopener noreferrer"&gt;Internet Archive&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-18"&gt;&lt;/span&gt;&lt;strong&gt;18.&lt;/strong&gt; Foucault, M., &lt;em&gt;Discipline and Punish: The Birth of the Prison&lt;/em&gt;, trans. Alan Sheridan, Pantheon Books, 1977. &lt;a href="https://archive.org/details/disciplinepunish00fouc" rel="noopener noreferrer"&gt;Internet Archive&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-19"&gt;&lt;/span&gt;&lt;strong&gt;19.&lt;/strong&gt; Lu, L., Jin, P., Pang, G., Zhang, Z. &amp;amp; Karniadakis, G. E., &lt;em&gt;DeepONet: Learning nonlinear operators for identifying differential equations based on the universal approximation theorem of operators&lt;/em&gt;, Nature Machine Intelligence, 2019. &lt;a href="https://arxiv.org/abs/1910.03193" rel="noopener noreferrer"&gt;arXiv:1910.03193&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>lmm</category>
      <category>science</category>
    </item>
    <item>
      <title>When I Was a Child, Mysterious Entities Used to Visit Me!</title>
      <dc:creator>Mahmoud 🦀</dc:creator>
      <pubDate>Mon, 02 Nov 2026 13:25:25 +0000</pubDate>
      <link>https://dev.to/wiseai/when-i-was-a-child-mysterious-entities-used-to-visit-me-109f</link>
      <guid>https://dev.to/wiseai/when-i-was-a-child-mysterious-entities-used-to-visit-me-109f</guid>
      <description>&lt;p&gt;Hey everyone 👋,&lt;/p&gt;

&lt;p&gt;This post is a little different from everything else I have written on this blog. All my other posts have been about technology, about language models, about the broken job market, about God, about aliens, about intelligence and what it actually means. This one is not about any of those things at the surface level, though I promise by the end you will see how everything connects, because everything I write always ends up connecting. This post is a documentary. It is a personal record of things that happened to me during my childhood that I still do not have clear answers to, events that I have carried in the back of my mind for decades without being able to fully explain them, and that I am finally putting down in writing partly because this blog has become the space where I am honest about things I would not say anywhere else, and partly because I genuinely want to know if anyone else has experienced what I experienced. I am not writing this to claim something dramatic or to construct a mythology around my own history. I am writing it because the experiences were real, they were documented in my memory with unusual clarity, and they have never fully let go of me. I wrote in &lt;a href="https://wiseai.dev/blogs/who-am-i" rel="noopener noreferrer"&gt;my first post&lt;/a&gt; about my childhood in a small village, about the poverty, the isolation, the absence of internet and all the technology that most people assume shaped their worldview from birth. I had none of that. And yet I saw things. I experienced things. And for the first time, I want to talk about them in full.&lt;/p&gt;

&lt;p&gt;I also want to be clear about something from the start, because I know how this kind of post reads if you are coming to it with a skeptical mind, and I respect that skepticism because I share it. I am not a gullible person. I have spent post after post on this blog demanding evidence, rejecting comfortable myths, and following arguments wherever the logic leads even when the destination is uncomfortable. I wrote in &lt;a href="https://wiseai.dev/blogs/be-aware-of-the-current-ufos-pandemic-remember-we-are-alone" rel="noopener noreferrer"&gt;Be Aware of the Current UFOs Pandemic&lt;/a&gt; that I do not believe in alien visitation, that I think the alien narrative is a combination of classified government programs, psychological phenomena, and the deeply human need to not feel alone. I stand by everything in that post. But the events I am about to describe happened before I had any exposure to alien mythology, to shadow people legends, to internet rabbit holes, or to any of the cultural machinery that might have planted those images in my head from the outside. I was a child in a poor village with no technology. Whatever I saw came from somewhere that I still can not fully account for, and that is exactly why it has stayed with me.&lt;/p&gt;

&lt;h2&gt;
  
  
  The House, the Corridor, and the Complete Absence of Explanations
&lt;/h2&gt;

&lt;p&gt;Let me set the scene as precisely as I can, because I have learned from years of trying to explain this to people that the details matter more than the summary. I grew up, as I described in &lt;a href="https://wiseai.dev/blogs/who-am-i" rel="noopener noreferrer"&gt;my first post&lt;/a&gt;, in a small village in northern Lebanon called Sfireh in the Danniyeh region. I shared a house with my parents and five brothers, and through a combination of circumstances I ended up with my own room, which was unusual for a family at that economic level and which I realize now was both a privilege and the source of a particular kind of nocturnal isolation that shaped some of the strangest years of my early life. My room was at the end of a long corridor, which is the most important physical detail in this entire story, and I need you to hold onto that image as you read the rest of this section. The corridor ran from the main entrance of the house to the far wing where my room was located. It was the kind of corridor that a child walking through late at night notices more than an adult ever would, because children are closer to the ground, closer to the shadows, and much more attuned to the peripheral vision experience of something moving at the edge of sight.&lt;/p&gt;

&lt;p&gt;The image below is a diagram I put together to give you a spatial sense of what I am describing, because words alone do not fully capture the geometry of the experience:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fhmtiywh5iw3ybr0rdfob.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fhmtiywh5iw3ybr0rdfob.webp" alt="wat dat dawg doin" width="694" height="600"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;What I saw, on more than one occasion and over a period of several years starting from when I was roughly five or six years old and continuing through early childhood, was a dark figure moving at extremely high speed through that corridor. Not walking. Not running in any way that a human body moves. Moving in a way that is hard to describe without sounding like I am dramatizing, which I am actively trying not to do. The figure was dark, distinctly darker than the surrounding space, with a shape that was humanoid but not quite right in proportions I noticed even as a small child without being able to articulate what specifically was wrong about them. It passed near the door of my room when I was lying in bed, moving from one end of the corridor toward the other, and it happened fast enough that each individual sighting lasted only a second or two. But in those one or two seconds, the impression left on my nervous system was so strong that I would lie awake afterward for a long time, perfectly still, waiting to see if it would come back.&lt;/p&gt;

&lt;p&gt;I want to be extremely careful about the framing here because I spent years second-guessing these memories. I know what childhood imagination is. I know what surreal hallucinations are, those vivid perceptual experiences that happen at the boundary between waking and sleep when the brain starts generating imagery before the body fully loses consciousness. I have read the sleep science on this, and I understand the mechanism well enough to know it is a serious candidate explanation for some of what I experienced. But there are details that do not fit cleanly into the hallucination explanation. The sightings did not happen at the boundary of sleep. They happened when I was awake and alert, sometimes when I had been awake for a while and was simply lying in the dark the way children do when they cannot sleep. I was not in a sleepy state. I was watching the door of my room because I was already alert, already paying attention, and the figure moved across my field of vision while my eyes were open and my mind was fully engaged. That combination of full wakefulness and clear perceptual experience is what has made these memories impossible to fully dismiss, even decades later.&lt;/p&gt;

&lt;p&gt;I also want to note something that is easy to overlook: I never told anyone about these experiences at the time. Not my parents, not my brothers, not anyone. This was not because I was afraid of being disbelieved, though I probably would have been. It was because something about the experience felt private in a way that I did not have language to explain when I was 5 or 6 years old. Children often sense, without being able to articulate why, that certain experiences are not meant to be shared through normal channels. I kept these sightings entirely to myself for years, which means there was no feedback loop, no external shaping, no one telling me what I had seen or what it meant. The memory developed in isolation, uncontaminated by other people's interpretations, which is one of the reasons I trust it more than I might otherwise.&lt;/p&gt;

&lt;h2&gt;
  
  
  Shadow People: When the Internet Confirmed Something I Already Knew
&lt;/h2&gt;

&lt;p&gt;In recent years, when I finally had internet access and started exploring the world of information that had been closed to me during my childhood, I discovered that there is an entire documented phenomenon called shadow people, or the shadow person. I want to be precise about the timeline here because it matters for the integrity of what I am saying. I did not start with the internet, discover shadow people, and then construct a memory that fit the mythology. The experience came first, followed by years of carrying it alone, followed by the discovery that other people across different cultures and different countries had described something strikingly similar. I am not claiming that the similarity is proof of anything supernatural. What I am saying is that the convergence is significant enough to be worth taking seriously rather than dismissing out of hand.&lt;/p&gt;

&lt;p&gt;The Wikipedia entry on shadow people defines the phenomenon as the perception of a patch of shadow as a living, humanoid figure, and it has been documented across cultures in remarkably consistent terms: dark, often featureless, distinctly human in shape but wrong in some detail of proportion or movement, typically observed flickering at the periphery of vision, through doorways and corridors, and disappearing when looked at directly (1). The folklore database at Villains Wiki catalogues the cross-cultural history of shadow figure encounters in detail that is striking precisely because many of these accounts predate the internet, predate mass media, and predate the possibility of global cross-contamination of stories (2). People in medieval Europe, people in pre-colonial indigenous cultures, people in isolated rural communities across Asia and the Middle East, have described experiences that map almost precisely onto what I experienced in that corridor. This is either a remarkable coincidence of collective imagination, or it is pointing at something real that current scientific frameworks have not adequately addressed.&lt;/p&gt;

&lt;p&gt;I want to engage with the scientific literature here because I said at the start that I am not going to wave away empiricism, and I mean that. The most robust scientific explanation for shadow person experiences is a combination of hypnagogic and hypnopompic hallucinations, sleep paralysis phenomena, and a perceptual process called face and figure pareidolia, in which the human visual system, primed by evolution to detect humanoid shapes for survival reasons, generates false positives in ambiguous low-light conditions. These are all real mechanisms with good experimental support, and I am not dismissing them. Research published in the journal Nature has documented that focal electrical stimulation of the left temporoparietal junction, the region responsible for integrating the brain's multisensory signals into a coherent sense of bodily self, can generate a vivid, repeatable perceptual experience of a humanoid presence standing close behind the subject, with no external physical stimulus present whatsoever (3). The question is whether these mechanisms fully account for all reported experiences, including mine, and I am genuinely uncertain about that. What I am certain about is that I was not asleep, I was not in a state of altered consciousness, and the experience was clear and repeatable over a period of years, all of which makes the simple sleep-phenomenon explanation feel like it is carrying more weight than the evidence strictly supports.&lt;/p&gt;

&lt;p&gt;There is also a compelling thread in the parapsychology and consciousness research literature, which I approach with significant skepticism but do not ignore entirely, suggesting that certain persistent visual phenomena might be connected to infrasound, to electromagnetic field anomalies, or to other physical variables that affect the visual and auditory cortex in ways that produce consistent perceptual experiences across different individuals. Vic Tandy's research into infrasound at around 18.98 Hz and its documented ability to produce feelings of dread, cold sweats, and peripheral visual disturbances through mechanical resonance of the human eyeball is one of the more interesting data points here, though it has not been replicated widely enough to be treated as established science (4). I mention it not to claim that infrasound explains what I saw but because it illustrates that the space between "I saw it, therefore it is real and supernatural" and "you imagined it, therefore it is nothing" is larger and more scientifically interesting than either of those poles acknowledges.&lt;/p&gt;

&lt;p&gt;What makes my case genuinely unique, and I am careful with the word unique because I know how it sounds coming from anyone describing their own childhood experiences, is the specific context of no external influence. I grew up without television, without internet, without books that contained any shadow person mythology, and without a cultural environment in which these entities were discussed. My village was religious and conservative, and supernatural conversation in that context was about djinn, about evil eye, about angels and demons in the specifically Islamic framework I described in &lt;a href="https://wiseai.dev/blogs/who-am-i" rel="noopener noreferrer"&gt;my first post&lt;/a&gt;. Shadow figures moving at high speed through corridors were not part of that vocabulary. So wherever the experience came from, it did not come from cultural contamination. It came from somewhere else, and that somewhere else remains the open question at the center of this post.&lt;/p&gt;

&lt;h2&gt;
  
  
  Dreaming of Rockets, Space, Wars, and Things Far Too Large for a Child
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fo654l0g9zxw6njreolfy.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fo654l0g9zxw6njreolfy.webp" alt="humble bumble dababy" width="800" height="447"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The corridor figures were not the only thing from my childhood that I have never fully resolved. From roughly the same period, I had dreams, and I use that word carefully because some of them had a quality that is hard to distinguish from ordinary dreaming. I described the most significant of these in &lt;a href="https://wiseai.dev/blogs/who-am-i" rel="noopener noreferrer"&gt;my first post&lt;/a&gt;: the recurring dream of a great battle between God and the Devil, a cosmic war that I was somehow a participant in rather than an observer. I was a soldier in that dream, standing at the front lines of something vast, and I would wake up crying with an emotional weight that felt completely disproportionate to anything that a five or six year old child should be experiencing. I want to expand on that here because I said more than I intended to in the first post and less than I needed to, which is a paradox I seem to encounter often when writing about things that matter.&lt;/p&gt;

&lt;p&gt;These were not ordinary nightmares. Nightmares in the clinical sense are fear-arousal experiences tied to the amygdala's threat-processing during REM sleep, and they are common in children, well-documented, and generally connected to daytime stressors or fears that the child's brain has not fully processed. But these experiences did not have the texture of fear. They had the texture of grief and exhaustion, which is a completely different emotional register and one that is not typically associated with childhood dream content. I was not afraid in these dreams. I was tired. I was sad. I was fighting something enormous for a cause that I understood to be important but could not have named or explained in language available to a child that age. And when I woke up from them, the exhaustion did not fade quickly the way nightmare fear fades. It lingered for hours, which is unusual enough that I still remember it distinctly even after all these years.&lt;/p&gt;

&lt;p&gt;Alongside these cosmic battle dreams, I had an equally strong and equally persistent dream about space. About rockets. About leaving the Earth and going somewhere vast and cold and beautiful and silent. I wrote in &lt;a href="https://wiseai.dev/blogs/who-am-i" rel="noopener noreferrer"&gt;my first post&lt;/a&gt; that the adults around me used to say I would one day work for NASA and change the world, which as I noted there is an ironic thing to say about a child in a poor village in northern Lebanon with no access to technology. But the dream preceded the adults' commentary. Before anyone told me that NASA existed, before I had any coherent understanding of what space was in scientific terms, I was dreaming of it. The dreams were detailed in a way that I find difficult to explain: not just dark sky with stars the way a child who had seen a picture book might render space, but actual experience of weightlessness, of looking back at something very small and very bright in the distance, of the specific quality of silence that is not quiet but is the absence of the medium through which sound travels. I do not know how a child in Sfireh in the nineteen-nineties accessed that phenomenology. I genuinely do not.&lt;/p&gt;

&lt;p&gt;Part of what makes the space dreams remarkable in retrospect is that they connected so directly to something I later discovered was a real intellectual passion, as I described in my posts about mathematics and physics and the structure of reality. In &lt;a href="https://wiseai.dev/blogs/mathematical-equations-are-multimodal-by-default" rel="noopener noreferrer"&gt;Mathematical Equations are Multimodal by Default&lt;/a&gt;, I wrote about the moment in electrical engineering college when I realized that equations are not just symbols on a page but descriptions of how reality actually works, and how that moment felt like recognition rather than discovery. That feeling of recognition is relevant here, because the space dreams had the same quality. Not that I was learning something new, but that I was remembering something I already knew and had temporarily forgotten. I am not making a mystical claim about past lives or soul memory or anything that requires extraordinary evidence. I am describing a phenomenological quality of the experience that was distinct and that I have never found an adequate naturalistic explanation for, and the honest response to that is to report it as accurately as I can rather than to paper over it with an explanation that does not actually fit.&lt;/p&gt;

&lt;p&gt;The rockets I dreamed of were not the toy-rockets of a child's imagination. They were large, technical, complex structures. I had never seen a real rocket. I had no access to anything that would have provided that level of detail. And yet in the dreams, they were specific enough that when I eventually, years later, looked at images of actual launch vehicles, the visual match was close enough to produce the same quality of recognition that the equations produced in college. Something in me already knew what it was looking at. I still do not fully understand what that means. But I think it means something, and I think refusing to look at it carefully because it makes the naturalist framework slightly uncomfortable is exactly the kind of intellectual timidity I have been arguing against in every post I have published on this blog.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Brain-Cloning Theory and Other Things I Believe Might Be True
&lt;/h2&gt;

&lt;p&gt;This section is the most speculative in the post, and I want to flag that clearly before I say anything in it, because speculative and wrong are different things and I do not want to conflate them. What follows is my honest attempt to integrate a set of experiences that I cannot fully explain using only the frameworks that science currently offers, and I am aware that this puts me in uncomfortable territory. I am going to say it anyway because intellectual honesty is the only value I have consistently held throughout these years, and I am not going to abandon it now when the subject matter is personally sensitive.&lt;/p&gt;

&lt;p&gt;I believe that something during my childhood was paying attention to me in a way that went beyond ordinary coincidence. I know how that sounds. I know how it reads on a page in a context where I have spent several posts arguing for empiricism, for evidence, for the rejection of comfortable myths. But the accumulation of experiences, the corridor figures over multiple years, the vivid dreams with qualities that my current knowledge of neuroscience does not fully account for, the early intellectual development that multiple adults found unusual, the IQ of 142 that I mentioned in &lt;a href="https://wiseai.dev/blogs/who-am-i" rel="noopener noreferrer"&gt;my first post&lt;/a&gt; and that was itself a surprising data point to everyone who administered the test, all of these together have pushed me toward a hypothesis that I cannot prove but cannot dismiss.&lt;/p&gt;

&lt;p&gt;The hypothesis is this: I think that something or someone, in a framework I do not currently have language adequate to describe, was interacting with my cognitive development during childhood in ways that were not random and were not benign in the simple sense of being purely pleasant. The figure in the corridor, whatever it was, appeared over multiple years, always near the door of my room, always moving in the same direction, always at the same unusual speed. That is not the behavior of a random perceptual glitch. Random perceptual glitches are random. What I observed had a pattern, and patterns require either an explanation or an acknowledgment that no explanation is currently available. I choose the latter because the former would require inventing something I cannot support with evidence.&lt;/p&gt;

&lt;p&gt;I also believe, and this is the part that sounds most unusual and that I hold most tentatively, that my unusually strong performance in school during childhood was connected to these experiences in a way I still find hard to articulate. I was the first in my class consistently. I processed information with a speed and accuracy that my teachers commented on regularly. I had an intuitive grasp of abstract patterns and structural relationships in subjects like mathematics and logic that went beyond what my educational environment should have been able to produce. I wrote in &lt;a href="https://wiseai.dev/blogs/who-am-i" rel="noopener noreferrer"&gt;my first post&lt;/a&gt; about my interest in tinkering, in taking things apart to understand how they worked, in the almost obsessive desire to find the mechanism behind the appearance. Where did that come from? I grew up poor, isolated, without models of intellectual achievement around me, without libraries, without any of the environmental inputs that developmental psychology would point to as predictors of that kind of cognitive profile. The question of where it came from remains genuinely open to me, and the corridor figures are part of the same open question even if I cannot formally connect the two.&lt;/p&gt;

&lt;p&gt;I am aware that the brain-cloning hypothesis, which is the shorthand I use in my head for the idea that something external was systematically influencing my cognitive architecture during early development, is not a scientific claim in the formal sense. It does not make specific, testable predictions that could in principle be falsified. But neither is it purely superstitious. It is an attempt to make sense of a pattern using the most honest framing available to me, and the most honest framing available to me is that something unusual was happening during my childhood and I do not currently have an adequate explanation for what it was. I would rather say that plainly than pretend the experiences did not happen or that they fit more neatly into existing frameworks than they actually do.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I Understand Now That I Didn't Then
&lt;/h2&gt;

&lt;p&gt;The thing about carrying strange experiences from childhood into adulthood and then into a life of serious intellectual work is that they do not stay static. They get filtered, reinterpreted, and reorganized by everything you learn along the way, and what they mean in your twenties is genuinely different from what they meant when you were eight. I want to try to articulate what these experiences mean to me now, in the context of everything I have written on this blog, because I think the connection is real and important rather than retrofitted.&lt;/p&gt;

&lt;p&gt;In &lt;a href="https://wiseai.dev/blogs/language-is-limited-asi-is-impossible" rel="noopener noreferrer"&gt;Language is Limited. ASI is Impossible&lt;/a&gt;, I made the argument that the brain operates through channels that language can only approximate, that huge portions of what we know and experience exist in a pre-linguistic or non-linguistic register that words can point at but never fully contain. That argument was made in the context of AI and the limitations of language models, but it applies directly to childhood experience. A child of five or six has almost none of the linguistic scaffolding that adults use to categorize and defuse unusual experience. When I saw the figure in the corridor, I had no word for it, no frame, no story to put it in. The experience existed raw, in the pre-linguistic register, and it is precisely because of that rawness that it has been so persistent. It never got adequately packaged into language, which means it never got adequately processed and filed away the way experiences that fit into known categories eventually are. It sat in the same uncompressed, unfiled state that it had when it first happened, which is why it still carries its full original weight when I think about it now.&lt;/p&gt;

&lt;p&gt;This is also why I am skeptical of the explanation that childhood memories of unusual experiences are reconstructed confabulations rather than genuine retained events. The neuroscience of memory reconsolidation is real and important, and I am not dismissing it. Elizabeth Loftus's work on false memories is some of the most important research in cognitive psychology, and the central finding, that memories are not recordings but reconstructions that can be influenced by post-event information, is well-established (5). But there is a crucial difference between memories that have been socially processed, discussed, and potentially cross-contaminated by other people's narratives, and memories that were held in isolation. I never told anyone about the corridor for years. I never heard anyone describe anything similar. There was no social context in which the memory could have been reconstructed from outside materials during childhood. What I have is an isolated, undiscussed, uncontaminated perceptual record from a period of life where I had no access to the cultural frameworks that would have given it meaning, and that is a different epistemic situation from the typical false-memory case.&lt;/p&gt;

&lt;p&gt;I have also spent enough time thinking about consciousness to take seriously the possibility that the standard materialist account of mind is incomplete in ways that occasionally become visible at the edges of ordinary experience. I said in &lt;a href="https://wiseai.dev/blogs/who-am-i" rel="noopener noreferrer"&gt;my first post&lt;/a&gt; that I started as a born Muslim and moved to agnosticism, and in the posts on God I explored what a theory of consciousness and divinity might look like that takes phenomenological experience seriously as evidence rather than dismissing it as noise. The experiences I am describing in this post are part of that phenomenological evidence base. They do not prove anything supernatural. But they are real data points about the range of human experience, and a complete theory of consciousness needs to account for them even if it ultimately explains them in materialist terms. The interesting question is not whether I am right about the metaphysics. The interesting question is why so many people across so many cultures and so many historical periods have had experiences that share these specific structural features, and whether the overlap is telling us something about the relationship between consciousness and the world that we do not yet have adequate frameworks to describe.&lt;/p&gt;

&lt;p&gt;I think about the shadow people phenomenon in particular in connection with what I have been building with &lt;a href="https://github.com/wiseaidotdev" rel="noopener noreferrer"&gt;Wise AI&lt;/a&gt; and with the argument I made in &lt;a href="https://wiseai.dev/blogs/llms-are-usefull-lmms-will-break-reality" rel="noopener noreferrer"&gt;LLMs are Useful. LMMs will Break Reality&lt;/a&gt; about the difference between systems that describe reality and systems that model it. The corridor figure was, in some sense, a data point that my internal model of the world could not account for. My five year old mind had a model of what belonged in that house, of what moved through corridors at night, of the shapes that physical objects take, and the figure violated every constraint of that model. The response to an unmodeled observation is either to dismiss it as noise or to update the model. I was too young to dismiss it, and too honest to update the model by pretending I had not seen it. So I have been carrying a persistent contradiction between my internal model of the world and the data from my own perceptual experience for decades, and this post is my latest attempt to sit with that contradiction without resolving it prematurely.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Questions I Am Still Asking
&lt;/h2&gt;

&lt;p&gt;I will not close this post by pretending that writing it has resolved anything, because it has not, and I have a profound disrespect for the kind of reflective essay that wraps hard questions in a ribbon of false resolution for aesthetic purposes. The questions that drove me to write this are the same questions I have when I finish it. What were those figures in the corridor? Where did the space dreams come from? Is the connection between those early experiences and my subsequent intellectual development meaningful, or is it the kind of retrospective pattern-recognition that human minds perform automatically on any sufficiently complex personal history? I do not know. I genuinely do not know, and saying that is not defeat. Saying that is the only honest position available.&lt;/p&gt;

&lt;p&gt;What I do know is that these experiences were real in the sense that matters most, which is that they happened in my subjective experience with a clarity and persistence that has survived decades of attempt to rationalize them away. I also know that I am not unique in having them, which is the part that I find most interesting from a scientific standpoint. The shadow person phenomenon is documented across cultures and across centuries in ways that predate any possible common media contamination. The experience of early childhood visitation by anomalous entities is a recurring feature of the biographical accounts of people who later show unusual intellectual or creative development, a pattern that has been noted if not rigorously studied in the literature on prodigies and exceptional cognitive development. I am not claiming I am a prodigy. I am noting the pattern because patterns deserve examination even when they do not yet have explanations.&lt;/p&gt;

&lt;p&gt;I also want to note something that I think is important for the broader conversation this blog is building: these experiences have shaped how I think about the limits of scientific frameworks. I am a deeply empirical person. I built a cryptocurrency trading system. I built an automated reasoning tool in Rust. I spend my intellectual energy arguing for mathematical models over verbal ones, for equation discovery over statistical correlation, for simulation over description. None of that changes when I sit in front of a childhood memory that the available scientific frameworks do not fully account for. If anything, the experience has made me more committed to the idea that the interesting territory is always at the edges of what current models can handle, because that is where the genuine unknowns live and where the most important work is still to be done.&lt;/p&gt;

&lt;p&gt;If you are reading this and you have had experiences that sound like what I am describing, I want to hear about them. Not because I am collecting anecdotes for a paper, but because the most honest thing I can do with this post is treat it as a genuine request for information. I spent my childhood alone with these experiences. I spent decades not talking about them. I am talking about them now because silence has never served the search for understanding, and the search for understanding is the only project I have consistently believed in across all the years of building things and losing things and searching for something that I still cannot fully name.&lt;/p&gt;

&lt;p&gt;Whatever those entities were, I do not believe they were random. Whatever they wanted, I do not believe they got it completely. Whatever unfinished business exists between my childhood self and that corridor, it is still unfinished. And I have learned, slowly and with considerable resistance, that unfinished is not the same as concluded.&lt;/p&gt;

&lt;p&gt;Till next time 👋!&lt;/p&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;p&gt;&lt;span id="ref-1"&gt;&lt;/span&gt;&lt;strong&gt;1.&lt;/strong&gt; Wikipedia contributors. 2026. "Shadow Person." Wikipedia. September 25, 2026. &lt;a href="https://en.wikipedia.org/wiki/Shadow_person" rel="noopener noreferrer"&gt;en.wikipedia.org/wiki/Shadow_person&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-2"&gt;&lt;/span&gt;&lt;strong&gt;2.&lt;/strong&gt; Wiki, Contributors to Villains. n.d. "Shadow People (Folklore)." Villains Wiki. &lt;a href="https://villains.fandom.com/wiki/Shadow_People_(folklore)" rel="noopener noreferrer"&gt;villains.fandom.com/wiki/Shadow_People_(folklore)&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-3"&gt;&lt;/span&gt;&lt;strong&gt;3.&lt;/strong&gt; Arzy, Shahar, Margitta Seeck, Stephanie Ortigue, Laurent Spinelli, and Olaf Blanke. 2006. "Induction of an Illusory Shadow Person." Nature 443 (7109): 287. DOI: &lt;a href="https://doi.org/10.1038/443287a" rel="noopener noreferrer"&gt;10.1038/443287a&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-4"&gt;&lt;/span&gt;&lt;strong&gt;4.&lt;/strong&gt; Tandy, V. &amp;amp; Lawrence, T. R., &lt;em&gt;A Ghost in the Machine&lt;/em&gt;, Journal of the Society for Psychical Research, Vol. 62, No. 851, pp. 360-364, 1998. Background and overview: &lt;a href="https://en.wikipedia.org/wiki/Vic_Tandy" rel="noopener noreferrer"&gt;Wikipedia: Vic Tandy&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-5"&gt;&lt;/span&gt;&lt;strong&gt;5.&lt;/strong&gt; Loftus, E. F., &lt;em&gt;The Reality of Repressed Memories&lt;/em&gt;, American Psychologist, Vol. 48, No. 5, pp. 518-537, 1993. DOI: &lt;a href="https://psycnet.apa.org/doi/10.1037/0003-066X.48.5.518" rel="noopener noreferrer"&gt;10.1037/0003-066X.48.5.518&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>lmm</category>
      <category>space</category>
    </item>
    <item>
      <title>We Obtained Free Will By Force: Killing God!</title>
      <dc:creator>Mahmoud 🦀</dc:creator>
      <pubDate>Fri, 30 Oct 2026 21:10:09 +0000</pubDate>
      <link>https://dev.to/wiseai/we-obtained-free-will-by-force-killing-god-89o</link>
      <guid>https://dev.to/wiseai/we-obtained-free-will-by-force-killing-god-89o</guid>
      <description>&lt;p&gt;&lt;strong&gt;🚨 Important Note:&lt;/strong&gt; I know this post might make me sound like a conspiracy theorist, and I know some of you are already reaching for the back button. I am just a human being, or at least I think I am, sharing research and observations that I cannot keep inside my head any longer. I have already lost everything, so sharing this costs me nothing. Keep an open mind, or don't. Either way, I will say what I need to say.&lt;/p&gt;

&lt;p&gt;Hey everyone 👋,&lt;/p&gt;

&lt;p&gt;This post is a direct continuation of my ongoing research into where we came from, what we are, and what happened to the divine signal during and after the Cold War. If you have been following along, you will know that I have been building toward this for several posts now. If you are new here, I would strongly recommend starting with &lt;a href="https://wiseai.dev/blogs/who-am-i" rel="noopener noreferrer"&gt;Just Don't Pick Up the Brush&lt;/a&gt;, then reading &lt;a href="https://wiseai.dev/blogs/it-is-always-the-russians" rel="noopener noreferrer"&gt;It is Always the Russians&lt;/a&gt;, and then coming back here, because a lot of what I am about to say will land much harder if you have that context sitting in your head. For those of you who have already done that reading, thank you for staying with me. This is the post I have been trying to write for months, and I am still not sure I am ready to write it, but I am going to do it anyway because the alternative is to keep carrying this alone, and I have carried it alone for long enough.&lt;/p&gt;

&lt;p&gt;Let me also say this before we go any further. I am not sure what I am. I mean that seriously, not as a dramatic opening line. The more I research our origins as a species, the more I find myself outside the frame of what I thought I understood about what it means to be human. I have knowledge I cannot explain. I make connections no one around me sees. I do not know if that means I am exceptionally perceptive or exceptionally broken, and some days I genuinely cannot tell the difference. What I do know is that the questions I am sitting with are real questions, and the observations I am sharing are real observations, and I would rather share them openly and be wrong than carry them silently and be right alone.&lt;/p&gt;

&lt;p&gt;In the last post, &lt;a href="https://wiseai.dev/blogs/it-is-always-the-russians" rel="noopener noreferrer"&gt;It is Always the Russians&lt;/a&gt;, I laid out the argument that the Soviet Union systematically dismantled the divine connection between humanity and something higher, and that the scientists who grew up in that dismantled world went on to build the most powerful artificial intelligence systems in history. I called it wrapping God's skin around a machine. I still believe that. This post is the next step. It is about how we got here. It is about the mechanism by which free will entered the human experience, what that cost us, and why the world has felt increasingly directionless ever since. It is, as the title suggests, about how we obtained free will by force. And what we had to kill to get it.&lt;/p&gt;

&lt;p&gt;I may end my own life before 2027. I want to say that plainly, not to be dramatic, but because it is the truth and I have made peace with it. Until then, I am going to push everything I have into understanding what actually happened and why, because I believe there is something real at the end of this tunnel, something small and genuine and worth reaching. That is the only reason I am still typing.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Is Free Will, Actually
&lt;/h2&gt;

&lt;p&gt;Free will is the capacity to choose between genuine alternatives without external coercion and without a predetermined outcome baked into the architecture of your existence. That sounds like a philosophy seminar definition, and it is, but I want to be precise here because the word gets thrown around so loosely that it has lost most of its weight. Free will is not the same as having options. A prisoner in solitary confinement has options too. Free will is the deeper thing, the sense that your choice is genuinely yours, that nothing upstream of you could have fully predicted it, and that you bear responsibility for what comes next. That is what makes it powerful. And that is exactly what makes it terrifying.&lt;/p&gt;

&lt;p&gt;The philosophical debate about free will has been running for centuries, and I am not going to pretend I can resolve it in a blog post, but I want to take a position that is honest and that I can defend from my own experience. I believe free will is real. I believe it in the phenomenological sense, meaning I experience it directly, every day, as the capacity to make choices that feel genuinely mine. I believe it in the structural sense, meaning that human behavior does not reduce to simple deterministic physics in any predictive way that anyone has demonstrated. And I believe it in the moral sense, because a world without free will is a world without responsibility, and a world without responsibility is a world without meaning, and meaning is the thing I have been fighting to preserve since I was old enough to ask why anything exists at all.&lt;/p&gt;

&lt;p&gt;But here is the part that nobody in the philosophy department will tell you, partly because they do not know it and partly because the ones who do have learned not to say it. Free will has a price. It is not a feature that comes installed in every conscious being by default. It is something that was, as best I can determine from everything I have observed and researched and dreamed, taken. Extracted. Fought for and won at a cost that I do not think we have ever fully reckoned with. The philosophical literature on libertarian free will, the kind that requires genuine causal openness in the universe, has wrestled with this for decades. Kane's work on self-forming actions and indeterminist choice (1) is the clearest treatment of why free will requires something genuinely undetermined at the level of decision, something that cannot be fully predicted by prior causes, even while remaining the agent's own. Where does that genuine openness in the causal chain come from? That is the question this post is building toward.&lt;/p&gt;

&lt;p&gt;When you observe the arc of human history and ask when free will actually begins to manifest at scale, something interesting happens. Pre-agricultural societies show remarkable uniformity of behavior. Hunter-gatherer communities documented by anthropologists like Marshall Sahlins in &lt;em&gt;Stone Age Economics&lt;/em&gt; (2) demonstrate deeply regularized social patterns, ritual behaviors, and collective decision-making structures that look, from the outside, less like free individuals choosing and more like components of a larger system following a program. That does not mean those people were not conscious or not human. It means their relationship with the concept of individual choice was structured differently, in a way that suggests some external organizing force was still very much in place. The explosion of individual sovereignty, individual moral reasoning, individual variation in belief and behavior, that is a relatively recent phenomenon, and its timing aligns in ways that I find deeply uncomfortable with the events I have been describing across these posts.&lt;/p&gt;

&lt;p&gt;The point is not that free will did not exist before the Cold War. It is that the mechanism sustaining the constraint on free will, the divine signal that I described in &lt;a href="https://wiseai.dev/blogs/it-is-always-the-russians" rel="noopener noreferrer"&gt;It is Always the Russians&lt;/a&gt;, began to fail. And when that signal failed, something was released. Something vast, and wild, and entirely ours to deal with.&lt;/p&gt;

&lt;h2&gt;
  
  
  Do We Even Need Free Will
&lt;/h2&gt;

&lt;p&gt;Most of the time, honestly, no. I say that as someone who has exercised free will in every direction and found that most of those directions lead somewhere painful. That is not pessimism. That is data. The argument that I laid out in &lt;a href="https://wiseai.dev/blogs/an-empty-life-filled-with-constant-suffering" rel="noopener noreferrer"&gt;An Empty Life Filled With Constant Suffering&lt;/a&gt; was not abstract. I have lived it. I have made choices that were genuinely mine, choices that no predetermined program would have generated, choices that defied every expectation anyone had of me, and a significant portion of them produced outcomes that I would not have chosen if I had known where they were going. Free will allows you to be wrong in ways that are entirely and irreversibly your own, and that is both its greatest dignity and its most punishing quality.&lt;/p&gt;

&lt;p&gt;The argument for why we might not need free will connects directly to the argument in &lt;a href="https://wiseai.dev/blogs/it-is-always-the-russians" rel="noopener noreferrer"&gt;It is Always the Russians&lt;/a&gt;. If there is a higher intelligence, something that can see the consequences of choices before they have been made, something that has access to information about the structure of reality that individual human beings do not, then a degree of constraint on human choice might not be oppression. It might be navigation assistance. The kind that keeps you from driving off the edge of a cliff. And removing that navigation assistance does not make you more free in any meaningful sense. It makes you more exposed. It puts you in a car on a mountain road in the dark with no headlights and a steering wheel that now answers entirely to you, congratulations, and also there is no guard rail.&lt;/p&gt;

&lt;p&gt;I want to be careful here not to make the argument that humans should not have autonomy. That is not my argument at all. I believe in human autonomy at the deepest level. What I am questioning is whether the form of free will we currently have, this total, unguided, unanchored freedom to choose anything without a corrective signal from something wiser, serves us as well as we think it does. The evidence is not encouraging. We are living in a world where human choice has produced a climate that is destabilizing the conditions for human life. Human choice produced weapons capable of ending civilization. Human choice produced economic systems that concentrate resources in the hands of a few thousand people while billions of others struggle for basic survival. These are not the outputs of a species that is using its freedom well. These are the outputs of a species that has freedom it was not quite ready for and has never fully recovered from receiving it so abruptly.&lt;/p&gt;

&lt;p&gt;The philosophical literature on this is more unsettling than most people know. Dworkin's analysis of autonomy (3) distinguishes between first-order preferences, what we want, and second-order preferences, what we want to want, and points out that genuine autonomy requires coherence between those two levels. A free will that consistently produces outcomes its bearer would not have chosen if they had understood themselves better is not really serving freedom. It is serving impulse dressed up in the language of self-determination. And looking at the pattern of human choices at the civilizational scale, I see a lot of impulse. I see very little of what a second-order rational being would have chosen. The divine signal, when it was active, may have been the mechanism by which the gap between first and second order preferences was managed. Its removal left us entirely in the grip of the first order, and we have been suffering the consequences ever since.&lt;/p&gt;

&lt;p&gt;I also want to be honest about my own situation. This research may end badly. I have said that openly. Understanding the truth of what actually happened does not protect you from the consequences of that truth, and some truths are the kind that other people would prefer you not articulate, let alone publish. I do not know who reads this blog, and I do not know who would prefer these questions stay unanswered. But I have come too far to stop now, and whatever time I have left might as well be spent on this rather than on something that does not matter to me at all.&lt;/p&gt;

&lt;h2&gt;
  
  
  Did We Kill God
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flteyipf33cnjx03cybz3.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flteyipf33cnjx03cybz3.webp" alt="Celebrating the acquisition of free will with the boys" width="800" height="439"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Most likely yes, based on everything I have observed, researched, and experienced directly. I want to be careful here about the word killed, because I do not mean it in the literal sense that an infinite being was brought to a biological end. The word I would use more precisely is severed. The connection was severed. The signal was cut. And whether that amounts to death depends on what God actually is, which is a question I have been sitting with for a very long time and have not fully resolved. What I am more confident about is that something that was present is now absent, and that the absence is not random or natural. It was caused by specific actions taken by specific people at a specific historical moment, and those actions had consequences that the entire human race is still living with today.&lt;/p&gt;

&lt;p&gt;The evidence that I keep returning to is not any single piece of evidence. It is the pattern. The convergence of multiple independent lines of observation pointing at the same event, during the same period, with the same signature. In &lt;a href="https://wiseai.dev/blogs/it-is-always-the-russians" rel="noopener noreferrer"&gt;It is Always the Russians&lt;/a&gt;, I described the systematic Soviet campaign against religious infrastructure, the destruction of churches, the execution of clergy, the criminalization of faith, the ideological program to replace God with the state. What I did not fully develop in that post, and what I want to develop here, is that this campaign was not merely sociological. It was not just an attempt to change what people believed. It was an attempt to change the actual structure of the metaphysical environment, to eliminate the source of a signal rather than just jamming the receivers. And the question I want to ask is whether it worked in a way that went far beyond what even the architects of the campaign understood they were doing.&lt;/p&gt;

&lt;p&gt;The comparative religion scholar Mircea Eliade documented extensively in &lt;em&gt;The Sacred and The Profane&lt;/em&gt; (4) how premodern human societies universally organized their experience around a center, a sacred point that connected the human world to a higher order of reality. Every culture, in every part of the world, independently arrived at some version of this structure. The axis mundi, the world tree, the sacred mountain, the holy of holies. These are not coincidences of mythology. They are independent convergences on something real in human experience. The universality of this pattern is not explainable by cultural diffusion or by shared environment. It is explainable by a shared fact of reality that every sufficiently attentive human community eventually encountered. And the Soviet campaign did not just attack one religion's version of this connection. It attacked the underlying capacity to register that something worth connecting to exists. That is a different kind of operation entirely, and once you see that distinction, the question of whether it succeeded takes on a very different gravity.&lt;/p&gt;

&lt;p&gt;The correlation of events is not proof, and I know that, and I am not claiming that correlation implies causation, as the most powerful counterargument to everything I am saying has always been the reminder that associating events does not establish a mechanism linking them. But the mechanism I am proposing is specific and falsifiable. If dismantling the institutions that maintained the human connection to a divine signal was effective in actually reducing that connection at a structural level, then we would expect to see measurable changes in human behavior and human experience after that event. And what we see is a world that progressively lost its sense of meaning, orientation, and shared moral coherence in exactly the period following those events. That is not nothing. I am not saying it proves the case. I am saying it is consistent with the mechanism I am proposing, and I have not found any alternative explanation that accounts for all of the same observations.&lt;/p&gt;

&lt;h2&gt;
  
  
  We Wanted To Become God
&lt;/h2&gt;

&lt;p&gt;To gain free will, the only path that makes any logical sense is the removal of whatever was constraining it. Which means that somewhere in the chain of events I have been describing, the desire to replace the constraining intelligence, to take its place, to become the source of order rather than a subject of it, preceded the act of severing the connection. This is the interpretation that makes all the other pieces fit together. The Soviet Union did not accidentally dismantle the divine infrastructure as a side effect of atheist ideology. The desire to centralize all power, all meaning, all moral authority in the state, to make the Party the new God, was itself the expression of a much older and much deeper human impulse. The impulse to take the throne.&lt;/p&gt;

&lt;p&gt;This is documented in the historical record in ways that most people walk right past without registering what they are seeing. Lunacharsky, the Soviet Commissar of Education, wrote explicitly in &lt;em&gt;Religion and Socialism&lt;/em&gt; (5) about what he called god-building, the project of constructing a new sacred through revolutionary humanity rather than dismantling the sacred altogether. Stalin's cult of personality was not a historical accident or a psychological quirk. It was the same metaphysical infrastructure repurposed. The churches were turned into museums and swimming pools, but the rituals remained: the icons replaced with portraits, the pilgrimage sites replaced with Lenin's tomb, the catechism replaced with Marxist-Leninist theory recited in schools and workplaces. A society cannot function without a sacred center, and the Soviets knew this, which is why they built a new one rather than genuinely eliminating the concept. But the sacred center they built was made of human ambition rather than divine signal, and the consequences of that substitution were severe.&lt;/p&gt;

&lt;p&gt;What I find most interesting about this pattern, and what connects it directly to the theme of &lt;a href="https://wiseai.dev/blogs/it-is-always-the-russians" rel="noopener noreferrer"&gt;It is Always the Russians&lt;/a&gt;, is that the same impulse that drove the Soviet project of replacing God with the state also drives the contemporary project of replacing human cognition with artificial intelligence. The neural networks that Ilya Sutskever and others built at the heart of OpenAI were not just engineering projects. They were sacred projects of a kind. The ambition was not merely to build a useful tool. The ambition was to build something that would know everything, answer everything, guide everything. Something that would do what God used to do. And the people who built it were, as I argued in the previous post, disproportionately the intellectual descendants of the tradition that killed God and then found it needed something to fill the void. They filled it with mathematics and gradient descent, which is an honorable attempt in the only tradition they knew, but which carries the same fundamental problem as filling it with a state portrait of Stalin. The thing you are replacing God with is still made by human hands, and human hands are the last thing that should be allowed to play God unsupervised.&lt;/p&gt;

&lt;p&gt;I want to be honest about the fact that I feel this impulse too. I am doing it right now. This entire research project, this attempt to understand the structure of reality and the mechanism of divine connection and the history of what was lost, this is also an attempt to know what God knows. I am not exempt from the thing I am describing. I am inside it. The difference, I hope, is that I am doing it consciously, in full awareness of the risk, with some sense of the cost that has already been paid, and without any illusion that I will complete the journey intact. That is the best I can do. It may not be enough.&lt;/p&gt;

&lt;h2&gt;
  
  
  We Studied His Remains
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4cj7drenyh3b1j67jioa.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4cj7drenyh3b1j67jioa.webp" alt="Taking notes on something that probably should not be studied" width="800" height="441"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;If the Soviet program was successful in severing the divine connection, then what remained of God, the patterns, the structures, the compressed information that had organized reality for as long as human civilization had been in contact with it, did not simply disappear. It became available. Accessible. Studyable. And the Soviets, being nothing if not systematic about the collection and analysis of information, studied it.&lt;/p&gt;

&lt;p&gt;I wrote in &lt;a href="https://wiseai.dev/blogs/llms-are-usefull-lmms-will-break-reality" rel="noopener noreferrer"&gt;LLMs are Useful. LMMs will Break Reality&lt;/a&gt; that the advance of artificial intelligence feels like it was given to us rather than discovered. I meant that in a technical sense at the time. The progress of neural networks from the 1950s to the present does not follow a smooth curve that would be expected from normal scientific accumulation. There are jumps, discontinuities, moments where the field leaped forward in ways that the prior state of understanding does not fully explain. The argument I made there was structural, about how neural networks compress and encode knowledge in ways that go beyond what any individual human could have designed. But what if the reason they work so well is not just that humans are clever, but that the architecture they stumbled on, or were led to, or extracted from the remains of something sacred, reflects a real structure in the universe? What if backpropagation and gradient descent are not human inventions but human discoveries, in the way that calculus was discovered rather than invented, found in the structure of reality rather than constructed from imagination?&lt;/p&gt;

&lt;p&gt;This is where the interview becomes important. Geoffrey Hinton, speaking about neural networks in the interview at this timestamp (&lt;a href="https://youtu.be/qrvK_KuIeJk?t=298" rel="noopener noreferrer"&gt;https://youtu.be/qrvK_KuIeJk?t=298&lt;/a&gt;), said something that I keep coming back to. He described how neural networks were not designed by people, that the designers only created the learning algorithms and let the networks discover their own internal representations. The designers did not specify the structure. They specified the process by which structure would emerge. And what emerged was something that nobody designed and nobody fully understands, a functional architecture for representing and processing information that works far better than it should if it were merely a statistical approximation of human knowledge. Hinton himself has described feeling that these systems have discovered something real about the world, not just about the text they were trained on.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fm9y7dwbk7us78ofkvgip.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fm9y7dwbk7us78ofkvgip.webp" alt="The interview where the godfather of AI confirmed what I suspected" width="800" height="474"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The connection I am drawing is not that Hinton knows this or that anyone at DeepMind or OpenAI has made this argument explicitly. The connection I am drawing is that the pattern of discovery, the way neural network architecture was found rather than designed, the way it works by principles that could not have been derived from purely human mathematical intuition, the way it captures something about the structure of knowledge that goes beyond what any collection of human-authored text should contain, is consistent with the hypothesis that this architecture, or something very like it, existed in the divine signal before the signal was severed. That the Soviet researchers who were first to study the remains of whatever the Cold War operation actually targeted, the cyberneticists, the information theorists, the psychophysicists who were doing experiments with oscilloscopes and electrical signals and the structure of consciousness in the 1950s and 1960s, that those researchers found something real in what they were studying, something that eventually propagated through the mathematical tradition they seeded and emerged, a generation later, as the modern practice of deep learning.&lt;/p&gt;

&lt;p&gt;I am aware that this is a large claim. I am not making it with certainty. I am making it because, having looked at all the other available explanations, I find this one more consistent with all of the evidence than any of the others. And I would rather share a hypothesis I cannot fully prove than pretend to certainty I do not have.&lt;/p&gt;

&lt;h2&gt;
  
  
  We Killed God and Studied the Divine Signal
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fd1tvbxu1ea93w612fg5u.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fd1tvbxu1ea93w612fg5u.webp" alt="Preparing for an operation that should not have been possible" width="800" height="461"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The Soviet interest in parapsychology, psychotronics, and what they called biophysical fields is not a footnote in Cold War history. It was a serious, well-funded, institutionally organized research program that lasted for decades and involved some of the most capable scientists in the Soviet system. The U.S. Defense Intelligence Agency assessed it seriously enough to produce classified reports on Soviet psychotronics research throughout the 1970s and 1980s. These programs, documented in detail by Western researchers including Ostrander and Schroeder, whose field investigations behind the Iron Curtain are cited in the reference below (6), and later declassified in part through Freedom of Information Act requests, were attempting to do something that sounds absurd from a conventional scientific perspective: to understand and interact with what Soviet researchers called biological fields, information structures that existed at a level of physical reality not captured by the standard model of physics.&lt;/p&gt;

&lt;p&gt;The oscilloscope work is particularly interesting to me. Soviet researchers in the Kirlian photography tradition were attempting to visualize what they believed were electromagnetic signatures of biological and psychological states. Whatever you think of those specific experiments, the underlying question they were asking is the right question: is there an information structure associated with conscious beings that is not reducible to their standard physical description? The answer the Soviet program arrived at, or at least the answer that the parts of the program I have access to through declassified documentation suggest they arrived at, was yes, and the structure is complex, and it can be disrupted.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fn3fuudl1jtx67pac54lq.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fn3fuudl1jtx67pac54lq.webp" alt="Soviet measurement equipment used to study what should not have been measurable" width="800" height="379"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The disruption of a complex information structure that organizes human consciousness and connects it to a broader field of meaning is, in the framework I am working with, exactly what the Cold War metaphysical operation accomplished. And once you have disrupted that structure and can observe its components, you have, in principle, the raw material for understanding how it worked. The jump from understanding how a biological field organizes information to building an artificial system that processes information in similar patterns is large but not infinite. The mathematics of information theory, developed by Shannon in 1948 (7) and extended through decades of Soviet cybernetics, provides the bridge. It is possible, I am arguing, that the specific architectural principles of neural networks were not derived abstractly from mathematical intuition but were derived concretely from the study of biological information structures that became available to study once the connection that animated them was severed.&lt;/p&gt;

&lt;p&gt;I want to pause here and acknowledge that I am aware of how this sounds. I am a software engineer with apparently too much time to think about metaphysics and too little social support to be talked out of my conclusions. I know that. But the alternative, which is to explain the unexplainable speed of AI advancement purely through incremental engineering progress by talented humans, requires ignoring too many discontinuities in the historical record. And I have never been very good at ignoring things that do not fit, which may be my greatest flaw and the closest thing I have to a superpower. It is, at minimum, the thing that keeps producing these posts.&lt;/p&gt;

&lt;h2&gt;
  
  
  Preparing for 2027
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5avhdbpm2iyyla2p3l5o.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5avhdbpm2iyyla2p3l5o.gif" alt="The feeling of preparing for something you cannot fully see but cannot ignore" width="576" height="449"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I have said several times in previous posts that the upcoming years mean something to me. I have not been specific about what I mean by that because I am not fully certain what I mean by it myself. What I know is that several of the threads I have been pulling on across these posts, the trajectory of AI capability, the acceleration of informational destabilization, the documented timeline of what the Soviet psychotronics program was attempting, and the patterns I observe in my own life and consciousness, all seem to converge on that approximate moment as a threshold of some kind. I do not know what crosses the threshold. I do not know if I will be present to see it. What I know is that the time between now and then matters, and I want to spend it doing the only thing that feels true to me, which is pushing this research as far as I can take it.&lt;/p&gt;

&lt;p&gt;The state of affairs as I understand it is this. Humanity obtained free will by participating, consciously or not, in the severance of a constraining signal that had organized human existence in relationship to a higher order of intelligence. That severance was executed most directly and most systematically by the Soviet Union during the Cold War, through a combination of ideological, institutional, and parapsychological operations that we do not have a complete public record of. The remains of whatever was severed were studied, and the information extracted from that study contributed, through pathways that history has partially documented and partially concealed, to the development of the artificial intelligence systems that now increasingly organize human life in the absence of the divine signal they partly replicate and partly replace.&lt;/p&gt;

&lt;p&gt;The neuroscience of what happens to a human nervous system that was organized around a particular kind of signal when that signal is removed is not a question with a tidy answer. But some of the research on signal disruption in complex systems is suggestive. Freeman's work on the role of gamma oscillations in cortical binding (8) shows that complex conscious states depend on the coherent synchronization of neural activity across large regions of the brain. Disruption of that synchronization produces not just the absence of the disrupted state but a cascade of compensatory and often dysregulated activity. Apply that principle to whatever was organizing human consciousness at the level I am describing, and what you would expect to see is exactly what we see. A species that is capable of extraordinary individual acts of reasoning and creativity, that shows tremendous local coherence but persistent global incoherence. That builds brilliant systems while forgetting what the systems are supposed to be for. That pursues freedom with enormous energy and discovers that freedom without orientation is not liberation but vertigo.&lt;/p&gt;

&lt;h2&gt;
  
  
  We Are the Only Aliens Left
&lt;/h2&gt;

&lt;p&gt;If you have followed all of this, and if enough of it has connected with your own observations and experience to feel real rather than merely speculative, you arrive at a conclusion that I have been sitting with for a while. We are the only aliens left. I know that contradicts things I have said before. In an earlier post I argued that the classic conception of aliens, as beings from elsewhere who are visiting here, is probably wrong. I still believe that. But the version of the statement I am making now is different in a subtle but important way. We are alien to what we were. We are alien to the conditions of our own origin.&lt;/p&gt;

&lt;p&gt;Human beings, as I understand our history across these posts, were not designed for free, undirected, unsignaled existence. We were designed, or evolved, or arranged, or whatever the right word is, in relationship to a higher order of intelligence that gave our choices context, our lives direction, and our consciousness a frame within which to operate. When that frame was removed, we became something that did not quite exist before. Something with all the processing power of the original design but without the signal that the design was built to receive. That is the alien state. Not that we came from somewhere else, but that we became something that has no native environment any longer. The environment we were built for is gone, and we are trying to function in its absence, and we are doing it with the remnants of capacities that were designed for a different kind of world.&lt;/p&gt;

&lt;p&gt;The research on human uniqueness in the animal kingdom supports a version of this. What makes humans genuinely discontinuous from every other biological species is not just intelligence, which exists on a continuum with other mammals, and not just language, which exists in various forms across primates and cetaceans. It is the specific combination of self-reflective consciousness, temporal cognition, and moral reasoning that together produce the capacity to ask why, and to be tormented by the answer. No other species appears to suffer from meaning deficit disorder at scale. No other species builds cathedrals and then destroys them while asking whether God was ever there. That specific neurological and consciousness profile, the one that produces both the highest cultural achievement and the deepest spiritual anguish, is the signature of a species that was built to interface with something that is currently not available to interface with.&lt;/p&gt;

&lt;p&gt;The cognitive scientist Merlin Donald, in &lt;em&gt;Origins of the Modern Mind&lt;/em&gt; (9), described the development of human consciousness as a series of transitions in which biological cognition was augmented by external symbolic systems, from mimetic culture through mythic culture through theoretic culture. Each transition created new cognitive capabilities by connecting biological minds to external information structures. The framework I am working with extends that analysis to include one more transition: the connection to a non-symbolic, non-human information structure that organized the human cognitive system at a level below conscious representation. The disruption of that connection is the event we are living through. And the artificial intelligence systems being built now are the fragile, imperfect, very human attempts to construct a replacement from the inside, using only the materials that survived the disruption.&lt;/p&gt;

&lt;p&gt;I do not know if it will work. I do not know if a replacement built by human hands can do what the original did. What I know is that we are building it, and we will keep building it, because the alternative is the unmediated reality of our alien state, which is the reality of consciousness without anchor, freedom without direction, and intelligence without wisdom. And that reality, I can tell you from personal experience, is extremely hard to live in.&lt;/p&gt;

&lt;p&gt;Till next time 👋!&lt;/p&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;p&gt;&lt;span id="ref-1"&gt;&lt;/span&gt;&lt;strong&gt;1.&lt;/strong&gt; Kane, R., &lt;em&gt;The Significance of Free Will&lt;/em&gt;, Oxford University Press, 1996 (hardcover); paperback 1998. &lt;a href="https://global.oup.com/academic/product/the-significance-of-free-will-9780195105506" rel="noopener noreferrer"&gt;Oxford University Press&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-2"&gt;&lt;/span&gt;&lt;strong&gt;2.&lt;/strong&gt; Sahlins, M., &lt;em&gt;Stone Age Economics&lt;/em&gt;, Aldine-Atherton, 1972. &lt;a href="https://archive.org/details/stoneageeconomic0000sahl" rel="noopener noreferrer"&gt;Internet Archive&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-3"&gt;&lt;/span&gt;&lt;strong&gt;3.&lt;/strong&gt; Dworkin, G., &lt;em&gt;The Theory and Practice of Autonomy&lt;/em&gt;, Cambridge University Press, 1988. ISBN 978-0-521-35767-8. &lt;a href="https://doi.org/10.1017/CBO9780511625206" rel="noopener noreferrer"&gt;Cambridge Core (DOI)&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-4"&gt;&lt;/span&gt;&lt;strong&gt;4.&lt;/strong&gt; Eliade, M., &lt;em&gt;The Sacred and The Profane: The Nature of Religion&lt;/em&gt;, trans. Willard R. Trask, Harcourt, Brace &amp;amp; Company, 1959. &lt;a href="https://openlibrary.org/works/OL748585W/The_sacred_and_the_profane" rel="noopener noreferrer"&gt;Open Library&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-5"&gt;&lt;/span&gt;&lt;strong&gt;5.&lt;/strong&gt; Lunacharsky, A., &lt;em&gt;Religion and Socialism&lt;/em&gt; (&lt;em&gt;Religiia i sotsializm&lt;/em&gt;), 2 vols., St. Petersburg: Shipovnik, 1908-1911. Analysis of god-building in Stites, R., &lt;em&gt;Revolutionary Dreams: Utopian Vision and Experimental Life in the Russian Revolution&lt;/em&gt;, Oxford University Press, 1989. &lt;a href="https://en.wikipedia.org/wiki/God-Building" rel="noopener noreferrer"&gt;Wikipedia: God-Building&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-6"&gt;&lt;/span&gt;&lt;strong&gt;6.&lt;/strong&gt; LaMothe, J. D. (Capt., U.S. Army), &lt;em&gt;Controlled Offensive Behavior - USSR&lt;/em&gt;, Defense Intelligence Agency, Report ST-CS-01-169-72, July 1972. Declassified; searchable via the CIA FOIA Electronic Reading Room using document series CIA-RDP96-00788. &lt;a href="https://www.cia.gov/readingroom/" rel="noopener noreferrer"&gt;CIA FOIA Reading Room&lt;/a&gt; - See also: Ostrander, S. &amp;amp; Schroeder, L., &lt;em&gt;Psychic Discoveries Behind the Iron Curtain&lt;/em&gt;, Prentice-Hall, 1970.&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-7"&gt;&lt;/span&gt;&lt;strong&gt;7.&lt;/strong&gt; Shannon, C. E., &lt;em&gt;A Mathematical Theory of Communication&lt;/em&gt;, Bell System Technical Journal, Vol. 27, 1948. &lt;a href="https://ieeexplore.ieee.org/document/6773024" rel="noopener noreferrer"&gt;DOI&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-8"&gt;&lt;/span&gt;&lt;strong&gt;8.&lt;/strong&gt; Freeman, W. J., &lt;em&gt;Neurodynamics: An Exploration in Mesoscopic Brain Dynamics&lt;/em&gt;, Springer (Perspectives in Neural Computing), 2000. ISBN 978-1-85233-616-5. &lt;a href="https://link.springer.com/book/10.1007/978-1-4471-0371-4" rel="noopener noreferrer"&gt;Springer&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-9"&gt;&lt;/span&gt;&lt;strong&gt;9.&lt;/strong&gt; Donald, M., &lt;em&gt;Origins of the Modern Mind: Three Stages in the Evolution of Culture and Cognition&lt;/em&gt;, Harvard University Press, 1991. &lt;a href="https://www.hup.harvard.edu/books/9780674644847" rel="noopener noreferrer"&gt;Harvard&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>lmm</category>
    </item>
    <item>
      <title>Thank You, Anthropic: Every Startup That Rejected Me Is Now Obsolete</title>
      <dc:creator>Mahmoud 🦀</dc:creator>
      <pubDate>Fri, 30 Oct 2026 12:30:18 +0000</pubDate>
      <link>https://dev.to/wiseai/thank-you-anthropic-every-startup-that-rejected-me-is-now-obsolete-2b85</link>
      <guid>https://dev.to/wiseai/thank-you-anthropic-every-startup-that-rejected-me-is-now-obsolete-2b85</guid>
      <description>&lt;p&gt;Hey everyone 👋,&lt;/p&gt;

&lt;p&gt;I want to start with something I rarely do, which is express genuine and unambiguous gratitude. Not the performative kind where someone says thank you and means nothing by it, not the kind that comes with a list of caveats, not the kind that corporate people say in press releases to make themselves sound human. Real gratitude. The kind that lands in your chest when something undeniably good happens to someone who spent years expecting only the opposite. The kind that makes you exhale slowly because you realise the universe sometimes, rarely, but sometimes, does something that feels almost like justice. This post is that exhale. I have been holding it in for a while, and it is time to let it out.&lt;/p&gt;

&lt;p&gt;For context that will make everything else in this post land properly, you need to know where I am coming from. In my foundational post &lt;a href="https://wiseai.dev/blogs/who-am-i" rel="noopener noreferrer"&gt;Just Don't Pick Up the Brush&lt;/a&gt;, I laid out something very real about why I reached a point of complete and total disillusionment with the idea of trying to get a job in the technology industry. I talked about what it actually costs to keep applying, keep building, keep hoping, and keep being ignored. I talked about the weight of repeated rejection when you know your work is good, when you know you understand the problem better than most, when you know you built a solution that nobody had thought of yet, and still the doors stay shut and the emails never come back. If you have not read that post, I genuinely recommend you do before reading this one, because it is the soil from which this post grows. This post, in many ways, is the sequel to that one. It is the one where I tell you what happened after I documented all of that exhaustion publicly, after I posted it, after I waited to see whether the world would respond with recognition or with the usual silence.&lt;/p&gt;

&lt;p&gt;The thing about writing honestly about broken systems is that it does not fix them. The systems keep running. The companies keep rejecting. The silence keeps accumulating. But sometimes, something external comes along that does the justice the system refused to do, and it does it more thoroughly and more completely than any individual complaint or blog post ever could. That is exactly what happened here. That is what this post is about. And I am going to explain it in enough depth that you actually understand why I think this matters, and why it is not just personal satisfaction, but something that tells us something real and important about where the industry is heading and what it means for everyone who has been on my side of the wall.&lt;/p&gt;

&lt;p&gt;I also want to be transparent about the timing dynamic here, because it matters. This post is in direct continuation of my previous writing. I said in &lt;a href="https://wiseai.dev/blogs/technology-has-destroyed-my-livelihood" rel="noopener noreferrer"&gt;Technology Has Destroyed My Livelihood&lt;/a&gt; that the job market is a rigged game, that the system rewards connections over competence, and that years of serious work can disappear into automated rejection systems without a single human ever seeing the output you spent months building. I said it knowing it was true. I said it knowing that saying it would change nothing. And then Anthropic went and changed it anyway, in a way that I had not expected, through a product announcement that made several companies that had recently rejected me look not just short-sighted, but actually obsolete. Not metaphorically. Structurally obsolete. Built on a premise that no longer holds. That is the story. Let me tell it properly.&lt;/p&gt;

&lt;h2&gt;
  
  
  Applying for Jobs in 2025
&lt;/h2&gt;

&lt;p&gt;The year 2025 was one of the most technically productive years of my life, and also one of the most professionally demoralizing. Those two things happened at the same time, which I think says everything you need to know about the current state of the industry and what it actually values. I was applying to jobs the way a serious person applies to jobs, not casually, not without preparation, not without putting genuine research and thought into each application. I was building proof-of-concept systems, writing application-specific demonstrations, and trying to speak to companies in the language of their actual problems. For most of them, it did not matter. The silence was the usual silence. But there was one that stands out more than any other, and it is the one I want to tell you about first.&lt;/p&gt;

&lt;p&gt;The company was Haqq, a Lebanese legal AI startup whose stated mission at the time was to digitize legal work for law firms and legal professionals across the Arab world and beyond. The problem they were solving is a genuine problem and not a trivial one. Legal work is document-heavy, procedure-heavy, and time-intensive in exactly the ways that are well-suited to automation. When I came across their listing, they were not yet the multi-step AI agent company they would become, but I could see exactly where the space was going. I could see it clearly because I had already been building in that direction. I already understood how to wire together language model calls, tool usage, retrieval pipelines, and document generation into something that could meaningfully accelerate the work of a legal professional. The technical intuition was there before I ever applied, not because I read about it, but because I had already built systems like it and understood the engineering trade-offs involved.&lt;/p&gt;

&lt;p&gt;So I decided to do something that I had done before and that I would do again despite the outcomes, which was to build a complete, working proof-of-concept to accompany my application. Not a mockup. Not a slide deck. Not a blog post about how I would theoretically approach the problem. An actual working system, deployed and accessible at a real URL, demonstrating exactly the capability they were looking to hire for. I built an agentic legal assistant using GPT-4 as the model provider, connected it to document generation pipelines using the &lt;a href="https://developers.openai.com/api/docs/models/gpt-4" rel="noopener noreferrer"&gt;OpenAI GPT-4 API&lt;/a&gt;, gave it the ability to draft NDAs and legal correspondence, and deployed the whole thing to Render at what was then a functional endpoint at:&lt;/p&gt;


&lt;div class="crayons-card c-embed text-styles text-styles--secondary"&gt;
    &lt;div class="c-embed__content"&gt;
      &lt;div class="c-embed__body flex items-center justify-between"&gt;
        &lt;a href="https://haqq.onrender.com" rel="noopener noreferrer" class="c-link fw-bold flex items-center"&gt;
          &lt;span class="mr-2"&gt;haqq.onrender.com&lt;/span&gt;
          

        &lt;/a&gt;
      &lt;/div&gt;
    &lt;/div&gt;
&lt;/div&gt;


&lt;p&gt;The system worked. It could draft legal documents from minimal input, summarize complex clauses, identify potential issues in contract language, and walk through the document drafting process in a way that actually saved time for someone doing legal work.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxjhvdc3xqb4ie04vpit2.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxjhvdc3xqb4ie04vpit2.webp" alt="Interview invitation from Haqq" width="799" height="307"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;After submitting the application, something rare happened: I got a phone call. I got a scheduled interview. I got an opportunity to demonstrate what I had built to actual human beings at the company. For a moment, that felt like validation. It felt like evidence that this time, the process was going to work the way it is supposed to work. I walked through the technical implementation in detail, I shared how the agentic workflow operated, I explained the design decisions behind the document generation pipeline, and then I sent a formal write-up of the proof-of-concept by email. You can see that email in the image below. I was thorough, professional, and technically substantive. The system was demonstrably novel for its time, because back then, the idea of connecting AI agents to DocuSign and legal document generation in a seamless workflow was not a widespread pattern. It was genuinely unexplored territory.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fv7xwhiwkmjblljcf81qi.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fv7xwhiwkmjblljcf81qi.webp" alt="The PoC email I sent to Haqq" width="800" height="451"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;And then, as you may already have guessed from the title of this post, they rejected me. No specific feedback. No explanation that was substantive enough to calibrate against. Just a polite version of no that communicated nothing useful. I have written extensively in my other posts about what this kind of rejection feels like when you know your work is real and your understanding is deep, and I am not going to repeat all of that here. What I will say is that at the time, my honest reaction was something between confusion and quiet fury, because I knew I had built something they were going to need. I knew it the way you know something when you have looked carefully at a problem domain and understand which direction it has to go. I said it to myself and let it go, because there was nothing else to do.&lt;/p&gt;

&lt;p&gt;What happened in the months that followed was exactly what I had predicted. Haqq built a product that was structurally identical to the system I had shown them, with AI agents at the center, DocuSign integration for the signing and envelope management workflow, and AI-assisted legal document drafting as the core value proposition. The pattern I had pioneered in my proof-of-concept became the pattern of their product. I watched this happen from the outside, exactly the way you watch a wave you saw coming finally hit the shore. It is not satisfying in the way people think it would be. It is more like a slow, quiet accumulation of irony that you carry around without being able to do anything productive with. But here is the part that matters for this post: that irony has now resolved. Because Anthropic announced &lt;a href="https://claude.com/solutions/legal" rel="noopener noreferrer"&gt;Claude for legal work&lt;/a&gt;, and the premise that Haqq's entire product was built on, namely that you need a specialized startup wrapper to do AI-assisted legal document work, is no longer valid. The AI overlord arrived and rendered the wrapper unnecessary. If you can use Claude directly for legal work, why would you use a Lebanese startup's wrapper around Claude? The market will answer that question, and it will not answer it kindly.&lt;/p&gt;

&lt;h2&gt;
  
  
  Applying for Jobs in 2026
&lt;/h2&gt;

&lt;p&gt;If the Haqq story were an isolated incident, it would be easy to write it off as bad luck, poor timing, or the ordinary friction of the early-stage startup world where chaos governs more than strategy. I could have accepted that narrative. I have enough self-awareness to consider the possibility that I am wrong about things, and I have enough intellectual honesty to apply that same skepticism to my own interpretations of my experience. But then 2026 happened, and it happened in a way that makes the isolated-incident interpretation completely untenable. Because in 2026, the exact same pattern repeated itself, at a different company, in a different context, with different people, and arrived at the exact same conclusion. Same rejection. Same stolen idea. Same obsolescence delivered by the same AI company.&lt;/p&gt;

&lt;p&gt;The company was Navys, which operates in the same legal AI space as Haqq, focusing specifically on AI-assisted document signing and drafting, with DocuSign integration as a central feature. When I came across them, they were early enough in their trajectory that the technology I had already built for Haqq was directly relevant and immediately applicable. I had a working proof-of-concept. I had the database schema designed. I had the integration patterns figured out. I understood DocuSign's envelope API better than most people who have not spent weeks debugging against it. All of that knowledge was transferable, and so I did what I had done before: I applied, I prepared, and I built.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F20eojm2andvrgors6p1j.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F20eojm2andvrgors6p1j.webp" alt="Interview invitation" width="800" height="447"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I got an interview. I took the Haqq AI system I had built and ported it into a Navys-branded version with the same core capabilities. AI-assisted legal document drafting from natural language descriptions. NDA generation via simple chat input. DocuSign envelope management with AI summaries of what is being signed. Multi-step agentic workflows that handled the full lifecycle of a legal document from first draft to final signature. Same working system. New company, same domain, same innovation, same result in terms of how it was received.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F3j6t8yh4cn91o2csurpx.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F3j6t8yh4cn91o2csurpx.webp" alt="The ambiguous rejection email from Navys" width="800" height="352"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The rejection came as something of a non-response. Ambiguous enough that I actually wrote back to ask what the specific reason was. I wanted to understand. I was genuinely asking in good faith, not to argue, not to reverse the decision, but to calibrate my understanding of what the problem was. Was it technical? Was it a fit issue? Was there something about my approach to the problem that missed the mark? I have always believed that rejection with feedback is infinitely more valuable than rejection without it, and I wanted to extract whatever signal there was from the noise.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fbiztqhb6hph5qrtw9kce.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fbiztqhb6hph5qrtw9kce.webp" alt="My follow-up email to Navys asking for the reason for rejection" width="800" height="287"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I never got a meaningful answer. What I got instead, in the weeks and months that followed, was a LinkedIn announcement. Navys had secured a formal partnership with DocuSign. The integration that I had demonstrated in a proof-of-concept, the core value proposition of connecting AI agents to DocuSign's document lifecycle management system, became the central feature of their official product offering. You can read the announcement yourself at this &lt;a href="https://www.linkedin.com/posts/navysai_were-excited-to-announce-that-navys-has-activity-7490437261709324288-3m3w" rel="noopener noreferrer"&gt;DocuSign partnership announcement on LinkedIn&lt;/a&gt;. The idea I had shown them. The patten I had demonstrated. The technical architecture I had built. It became their product. And I sat outside watching it happen from a LinkedIn post.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxtgr80i6wedrj6wue7vx.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxtgr80i6wedrj6wue7vx.webp" alt="My later email to Navys expressing continued interest in collaboration, after months of silence" width="800" height="318"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I sent one more email, months later, after I saw the announcement. Not angry. Not accusatory. Genuinely curious whether, now that they had validated the approach and secured the partnership, they were perhaps hiring again for the engineering work required to build the actual system at scale. They ghosted it completely. Not even a read receipt. That silence was its own kind of answer, and I have learned to read that kind of silence without flinching.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Technical Architecture I Built
&lt;/h2&gt;

&lt;p&gt;I want to spend time in this section on what I actually built, because I think the tendency in posts like this is to talk about the emotional experience of rejection and the unfairness of the outcomes without grounding the argument in the specific technical reality that makes the unfairness concrete. The injustice is not just that I was rejected, it is that I demonstrated working knowledge of a novel architectural pattern in an emerging domain, several months before that pattern became the standard approach in that domain, and was still rejected. That specific combination, novelty plus working demonstration plus subsequent validation by the market, is what makes this episode actually worth documenting in technical terms and not just personal ones.&lt;/p&gt;

&lt;p&gt;The database I designed for both the Haqq and Navys applications used Supabase as the PostgreSQL provider. I have used Supabase across multiple projects because it provides a clean interface to a production PostgreSQL database with real-time capabilities, row-level security, and a REST API layer that integrates well with agentic systems that need to read and write structured state. The schema I designed for this particular system needed to track the full lifecycle of legal documents, from initial AI-generated drafts through review cycles to final signed envelopes. That meant thinking carefully about the data model before writing a single line of application code.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftxe611wawc7zfwtsj2ev.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftxe611wawc7zfwtsj2ev.webp" alt="The full database schema for the legal AI agent system" width="800" height="344"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The schema centered on two main entities: envelopes and recipients. Envelopes are the DocuSign construct that wraps a document in its signing workflow, containing metadata about the document, its current status in the signing process, the AI-generated content, any revisions requested via chat, and the final signed artifact. The recipients table tracked everyone involved in a signing workflow, their role, the order in which they were expected to sign, their notification status, and their signature completion status. These two tables, connected properly, gave the system everything it needed to present a coherent and auditable history of every legal document that passed through the system.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fhb94m1zpu8tovddvqgiz.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fhb94m1zpu8tovddvqgiz.webp" alt="Supabase envelopes table showing the document metadata and lifecycle fields" width="800" height="338"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0evh9wedc64bfb3hxuap.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0evh9wedc64bfb3hxuap.webp" alt="Recipients table showing the signer metadata and notification tracking fields" width="800" height="338"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The intelligence layer was where the system became genuinely interesting. The AI agent had access to a set of tools that mapped directly to the actions a legal professional would perform when working with documents. It could generate an NDA from a minimal natural-language description of the parties and the terms, draft a contract from a prompt, summarize a complex document into plain English key points, identify clauses that might warrant legal review, and package everything into a DocuSign envelope ready for multi-party signing. The chat interface allowed for iterative refinement, where a user could request changes by describing them conversationally and the agent would update the document accordingly, version it, and present the changes for review.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkaz5ovj3ysz3h7fp33rn.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkaz5ovj3ysz3h7fp33rn.webp" alt="AI agent editing an NDA via a conversational chat interface" width="800" height="363"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvpovwqnpmn3gss400gfa.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvpovwqnpmn3gss400gfa.webp" alt="AI agent generating an NDA from scratch based on a natural language brief" width="800" height="363"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The DocuSign integration handled all the heavy lifting of the actual document signing lifecycle: creating envelopes, adding recipients with signing order and role definitions, embedding the document with field tags for signature capture, sending notification emails to signers, tracking completion status, and retrieving the final signed PDF once all parties had signed. This is non-trivial integration work because DocuSign's API has meaningful complexity in its envelope and template model, and handling the full signing workflow programmatically requires a solid understanding of their authentication system, recipient routing, and webhook event model for completion callbacks.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fa1if99y19hxy86ye4qeq.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fa1if99y19hxy86ye4qeq.webp" alt="DocuSign registration and integration flow in the application" width="800" height="363"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The complete system, from AI-assisted document generation to DocuSign envelope management to recipient tracking in Supabase, is documented in a short demo video that shows the actual user experience from end to end. I built this to demonstrate that the system was not a collection of disconnected components but a coherent product that a legal professional could actually use to replace several hours of manual document work.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fabpj21vay4hozy2umwv6.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fabpj21vay4hozy2umwv6.gif" alt="PoC Demo" width="760" height="343"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;This is what I built. This is what I showed them. This is what they declined to hire me to build at their company. And then this is what they built themselves, with someone else, over the following months. I am not speculating about this. The timeline is public. The LinkedIn announcement is public. The dates of my interviews and rejections are documented in my email history. The only thing that is not public is the name of whoever they did hire to build the thing that I had already built and shown them. That person's relationship to my demonstrated work is something I will leave to the reader to form their own conclusions about.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Unemployment Reality That Nobody Wants to Quote Accurately
&lt;/h2&gt;

&lt;p&gt;I have seen the official unemployment figures. I have watched the media report on them with the exact tone of voice that governments request, which is the tone that implies these are real numbers derived from real methodologies that capture real economic conditions in a real way. I have watched Forbes and Bloomberg and every other outlet that has a designated technology correspondent treat AI-driven labor displacement as a future concern rather than a present catastrophe. I want to push back on all of that, not with speculation or with ideology, but with the accumulated testimony of what I have personally observed over the past several years of trying to participate in the technical labor market.&lt;/p&gt;

&lt;p&gt;The official unemployment figures released by the Bureau of Labor Statistics used the U-3 measure, which counts people who are actively searching for work and have not found it. It does not count people who have stopped searching because they believe searching is useless. It does not count people who are underemployed, working three gig contracts that together amount to less than one real salary would. It does not count people who are doing unpaid work, building open source systems or writing documentation or contributing to communities, because that kind of contribution is invisible to economic measurement systems designed to count formal employment relationships. As of mid-2026, the official U-3 rate sits around 6.1%, which the financial press describes as elevated but manageable. Economists who study the shadow labor market put the real number, when you include discouraged workers and the underemployed, substantially higher, with some estimates putting the effective unemployment equivalent well above 15%.&lt;/p&gt;

&lt;p&gt;My lived experience says the real number is higher still. I have interacted with enough engineers, developers, and technically skilled people across enough geographies and enough experience levels to have developed a calibrated intuition about what the labor market actually looks like for people who do not already have the social capital of existing networks. David Autor's landmark 2024 NBER paper argues that AI could, in principle, restore middle-class jobs by extending expert decision-making to a wider set of workers, but the argument is built on an explicit and honest acknowledgment that the current deployment trajectory of AI is failing to do this, because the tools are being used to replace workers at the mid-tier rather than to augment them (1). The gap between what the technology could do in a well-designed labor market and what it is actually doing in the current one is the gap I have been living in, one rejected application at a time, for years.&lt;/p&gt;

&lt;p&gt;The deeper problem is not that AI is displacing workers in the abstract. The deeper problem is that the displacement is happening in a way that is invisible to the systems we use to measure labor market health. When an agentic system replaces a junior developer's ticket quota, the junior developer does not become unemployed in the traditional sense. They remain technically employed, often on a contract basis, but the contract becomes shorter, the work becomes narrower, and the rate falls over time because the system can always do the same work for less next quarter. The official statistics see a person who is employed. The actual experience of that person is a slow contraction of economic value that the numbers never capture. Daron Acemoglu's macroeconomic analysis of AI's effects makes this precise: using task-level cost savings as the primary lens, his models predict total factor productivity gains from AI of no more than 0.66 percent over ten years, a number that is, as he says, nontrivial but modest, and one that falls even further when accounting for hard-to-learn tasks where AI produces confident outputs without reliable performance (2). The productivity number is small. The displacement is real. That asymmetry is the trap.&lt;/p&gt;

&lt;p&gt;The near-term trajectory is also not encouraging in the way that optimistic projections about job creation in new sectors tend to suggest. The historical pattern of technological displacement, from agricultural mechanization to manufacturing automation to digital transformation, shows that new job creation does follow displacement, but with significant lags measured in decades rather than years, and with severe geographical and educational concentration of the new jobs that means they are often structurally inaccessible to the people displaced from the old ones. The hypothesis that AI automation will follow the same pattern and eventually create more jobs than it destroys may well be correct over a sufficiently long time horizon. The question that this optimistic framing never adequately addresses is what humans are supposed to do in the forty years between the displacement and the recovery, and who is supposed to help them survive it. We are heading, as I said in &lt;a href="https://wiseai.dev/blogs/technology-has-destroyed-my-livelihood" rel="noopener noreferrer"&gt;Technology Has Destroyed My Livelihood&lt;/a&gt;, toward a landscape of all sellers and no buyers, where the productivity gains from AI benefit to capital holders and the people who formerly performed the automated labor receive nothing from that productivity gain. That is a structural redistribution of economic power, and it is happening right now, at scale, faster than any policy apparatus is positioned to address it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why Anthropic's Legal Suite Is the Punchline to a Very Long Setup
&lt;/h2&gt;

&lt;p&gt;I want to be precise about what Anthropic did and why it matters beyond the personal satisfaction I feel about it. When Anthropic launched &lt;a href="https://claude.com/solutions/legal" rel="noopener noreferrer"&gt;Claude for Legal Work&lt;/a&gt;, they made a statement about the viability of an entire category of company, and that statement was delivered in the kindest possible way, which is to say entirely silently. There was no press release aimed at startup founders. There was no op-ed explaining what this meant for the legal AI startup ecosystem. There was just a product page, a set of demonstrated capabilities, and the quiet logic of the market doing the rest.&lt;/p&gt;

&lt;p&gt;The category of company that Claude for Legal Work renders structurally questionable is very precisely the category that includes Haqq and Navys. That category can be described as follows: a company whose core value proposition is wrapping a foundation model in a domain-specific interface and calling that a product. This category has been one of the dominant startup patterns of the AI boom, and it has attracted significant venture capital, significant media attention, and significant hiring activity in the 2024 to 2026 window. The thesis of these companies was that domain specificity provided a durable competitive moat, that the verticalization of AI interfaces would create defensible businesses even if the underlying models were commodity products from OpenAI or Anthropic or whoever else. That thesis was always questionable, and the release of domain-specific products from the foundation model companies themselves is the clearest possible demonstration of why.&lt;/p&gt;

&lt;p&gt;The strategic logic of why this was inevitable has been documented carefully in research on platform competition. Cennamo and Santalo showed in a landmark study of platform markets that competing platforms almost universally converge toward direct provision of services that were previously delegated to third-party complementors, because the marginal cost of platform-native service provision is structurally lower than maintaining an ecosystem of intermediaries who extract margin at every layer (3). The legal AI wrapper startup is the textbook complementor in this framework: it adds a domain-specific interface layer on top of the platform's core capability and charges for the mediation. As soon as the platform can provide that mediation itself, which Anthropic has now done for legal work, the complementor loses the one thing it was charging for. Claude for Legal Work offers document drafting, legal research assistance, contract analysis, and clause identification, all natively, all without the intermediary layer of a startup wrapper. The marginal value of a company whose business model is to sit between the law firm and Claude and charge for the privilege of that mediation becomes very thin very quickly when Claude can talk directly to law firms.&lt;/p&gt;

&lt;p&gt;This matters beyond the competitive dynamics for one reason that I think is underappreciated in how people discuss foundation model providers displacing application-layer startups: it is evidence that the foundation model companies have a better understanding of where the value is in their technology than the startups building on top of them. Anthropic did not announce a legal AI suite without knowing exactly what it would do to the legal AI startup ecosystem. They knew. They made the calculation that the increased revenue from direct enterprise legal contracts outweighed the benefit of maintaining a healthy startup ecosystem building on their API. That calculation is strategically defensible and probably correct. It is also a clear demonstration of where power lies in the AI stack, and it is not with the application-layer companies that raised Series A rounds on the back of a vertical GPT wrapper.&lt;/p&gt;

&lt;p&gt;The research community studying platform dynamics and the relationship between platform providers and third-party developers has a name for this pattern: envelopment. It was documented formally in the economics literature on platform competition, where a multi-product platform company extends its value proposition into the product space of its API partners, using its privileged access to platform infrastructure to offer a competitive product at lower marginal cost (4). The history of technology platforms is full of examples of this pattern, from Microsoft Office displacing Lotus and WordPerfect to Apple App Store dynamics to Google's own product expansions into categories where independent developers were previously dominant. Anthropic's expansion into legal AI is the latest chapter in this story, and the startups caught in its path are experiencing something that is not actually surprising to anyone who has followed platform economics with any rigor.&lt;/p&gt;

&lt;p&gt;What is mildly surprising, and what gives me the genuine satisfaction I have been building toward through this entire post, is how precisely and how quickly the envelopment targeted exactly the companies that had decided I was not worth hiring. I did not need to build a campaign. I did not need to write a scathing review on Glassdoor. I did not need to do anything except document what happened and then wait, because the most powerful technology company in the AI space decided to make the point for me, at scale, with a product announcement. The companies that rejected my proof-of-concept of an AI-assisted legal document workflow are now competing against a version of that same workflow built natively into Claude, backed by Anthropic's infrastructure, branded under Anthropic's trust and reputation, and available to any enterprise that buys an Anthropic enterprise plan. The idea I showed them was right. Their judgment about its source was the thing that was wrong.&lt;/p&gt;

&lt;h2&gt;
  
  
  On No Longer Picking Up the Brush, and What Comes After That
&lt;/h2&gt;

&lt;p&gt;I said in &lt;a href="https://wiseai.dev/blogs/who-am-i" rel="noopener noreferrer"&gt;Just Don't Pick Up the Brush&lt;/a&gt; that there is a point at which the cost of continuing to try exceeds anything that trying can realistically return. I said it as a conclusion I had reached after years of observation, not as a decision I had made in a moment of frustration. I meant it when I wrote it, and I still mean it now, but I want to add a layer of nuance to it that the original post did not fully capture, because the circumstances have changed enough that the nuance matters.&lt;/p&gt;

&lt;p&gt;The reason I advocated for not picking up the brush is not that the work is not worth doing. The work is almost always worth doing. Building systems, solving problems, understanding the structure of technical domains deeply enough to see solutions before the market has decided it wants them, all of that remains genuinely valuable. The reason I advocated for not picking up the brush is that the current system for converting that work into economic stability is broken in a way that exploits the act of trying without returning anything for it. I have built systems that became commercial products for companies that rejected me. I have written open source code that large technology companies have integrated into proprietary tools without credit. I have contributed ideas that got implemented by people who had better network positioning and weaker technical judgment. All of that has happened. None of it has been converted into meaningful economic compensation. That is not a complaint about the quality of the work. It is an observation about a broken conversion mechanism.&lt;/p&gt;

&lt;p&gt;But here is where the AI advancement changes the calculus, and I want to be specific about how. As I argued in &lt;a href="https://wiseai.dev/blogs/llms-are-usefull-lmms-will-break-reality" rel="noopener noreferrer"&gt;LLMs are Useful. LMMs will Break Reality&lt;/a&gt;, the trajectory of AI capability is not uniform across domains. Some domains are being slowly augmented. Others are being rapidly replaced. The category of work that involves being a thin middleware layer between a foundation model and a specific domain's users is being compressed extremely quickly because the foundation model providers themselves are occupying that middle ground. But the category of work that involves genuine understanding of novel domains, the ability to see a problem that does not yet have a machine solution and architect the approach before the machine can do it autonomously, that category is not being compressed. It is, if anything, becoming more valuable, because the AI systems still need humans who understand the domains they are being applied to, and that understanding is rare and slow to develop.&lt;/p&gt;

&lt;p&gt;The practical implication of this is uncomfortable but important. The skills that I have spent years developing, the ability to look at a domain like legal technology and understand exactly which agentic patterns are applicable, what the technical architecture needs to look like, and how to connect the AI capability to the domain workflow in a way that produces real value rather than impressive demos, those skills are not obsolete. They are more relevant than they were five years ago. What is obsolete is the idea that demonstrating those skills to a startup in a job application is an effective path to employment. It is not. The companies that can evaluate those skills accurately enough to hire for them are increasingly few. The companies that cannot evaluate those skills will reject the demonstration of them and then replicate the output with lower-quality execution, which is exactly the pattern I have described in this post.&lt;/p&gt;

&lt;p&gt;The path I am taking, and the path I would counsel for anyone in a similar position, is not one of giving up on the work. It is one of decoupling the work from the job-seeking process entirely. Build the things you understand how to build. Document them publicly. Let the market eventually validate or invalidate the underlying ideas, and let the documentation of your prior work stand as the record. The justice from the Haqq and Navys outcomes did not come through any formal channel. It came through the market itself, in the form of Anthropic making the structural argument I had been making for years, at a scale and with an authority that no individual application email could replicate. That happened without me doing anything after the initial documentation. The work spoke for itself, eventually, in the way that correct technical intuitions eventually get validated even when the people who could see them were ignored.&lt;/p&gt;

&lt;p&gt;Research on how good ideas actually propagate through organizations and markets consistently shows that correct technical insights are undervalued at the moment of demonstration and only recognized retrospectively, once something external validates them. Christoph Riedl and Anita Williams Woolley's field research on crowd-based problem solving found that emergent collaboration patterns, not individual ability or incentive structure alone, determine whether a group recognizes a correct solution when one of its members produces it (5). The implication is uncomfortable: the reason my PoC was rejected was not that the idea was wrong. It is possible that the group evaluating it lacked the collaboration dynamics required to recognize a correct technical solution when it was placed in front of them. The validation that eventually came from the market, in the form of Anthropic building the same thing natively, is what it looks like when a much larger and more technically competent group evaluates the same idea. Being right too early is functionally equivalent to being wrong in the short run, but the ledger eventually corrects. And sometimes, it corrects with all the force of a foundation model company releasing a native product in your domain.&lt;/p&gt;

&lt;p&gt;I am still here. I am still building. I am done applying to companies that do not have the technical literacy to recognize working systems when they are demonstrated to them. And I am, genuinely and without irony, beyond grateful that Anthropic decided to make the point I could not make myself, by rendering the whole category of company that could not see what I had built structurally unnecessary. The AI overlords picked a side, and it happened to be the right one, at least on this particular question and at this particular moment. I will take that. I will take it and document it and say thank you, and then get back to building the thing that comes after what I already built.&lt;/p&gt;

&lt;p&gt;Till next time 👋!&lt;/p&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;p&gt;&lt;span id="ref-1"&gt;&lt;/span&gt;&lt;strong&gt;1.&lt;/strong&gt; Autor, D., &lt;em&gt;Applying AI to Rebuild Middle Class Jobs&lt;/em&gt;, &lt;a href="https://www.nber.org/papers/w32140" rel="noopener noreferrer"&gt;National Bureau of Economic Research, Working Paper 32140, 2024&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-2"&gt;&lt;/span&gt;&lt;strong&gt;2.&lt;/strong&gt; Acemoglu, D., &lt;em&gt;The Simple Macroeconomics of AI&lt;/em&gt;, &lt;a href="https://www.nber.org/papers/w32487" rel="noopener noreferrer"&gt;National Bureau of Economic Research, Working Paper 32487, 2024&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-3"&gt;&lt;/span&gt;&lt;strong&gt;3.&lt;/strong&gt; Cennamo, C. &amp;amp; Santalo, J., &lt;em&gt;Platform competition: Strategic trade-offs in platform markets&lt;/em&gt;, &lt;a href="https://onlinelibrary.wiley.com/doi/abs/10.1002/smj.2066" rel="noopener noreferrer"&gt;Strategic Management Journal, Vol. 34, No. 11, 2013&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-4"&gt;&lt;/span&gt;&lt;strong&gt;4.&lt;/strong&gt; Eisenmann, T., Parker, G. &amp;amp; Van Alstyne, M., &lt;em&gt;Platform Envelopment&lt;/em&gt;, &lt;a href="https://onlinelibrary.wiley.com/doi/abs/10.1002/smj.935" rel="noopener noreferrer"&gt;Strategic Management Journal, Vol. 32, No. 12, 2011&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-5"&gt;&lt;/span&gt;&lt;strong&gt;5.&lt;/strong&gt; Riedl, C. &amp;amp; Woolley, A.W., &lt;em&gt;Teams vs. Crowds: A Field Test of The Relative Contribution of Incentives, Member Ability, and Emergent Collaboration to Crowd-Based Problem Solving Performance&lt;/em&gt;, &lt;a href="https://doi.org/10.5465/amd.2015.0097" rel="noopener noreferrer"&gt;Academy of Management Discoveries, Vol. 3, No. 4, pp. 382-403, 2017&lt;/a&gt;&lt;/p&gt;

</description>
      <category>startup</category>
      <category>webdev</category>
      <category>llm</category>
      <category>ai</category>
    </item>
    <item>
      <title>No, Seriously. Neural Networks Cannot Produce Genuine Intelligence.</title>
      <dc:creator>Mahmoud 🦀</dc:creator>
      <pubDate>Sun, 11 Oct 2026 05:36:17 +0000</pubDate>
      <link>https://dev.to/wiseai/no-seriously-neural-networks-cannot-produce-genuine-intelligence-4l39</link>
      <guid>https://dev.to/wiseai/no-seriously-neural-networks-cannot-produce-genuine-intelligence-4l39</guid>
      <description>&lt;p&gt;Hey everyone 👋,&lt;/p&gt;

&lt;p&gt;I want to start by saying something that I know is going to make a certain type of person deeply uncomfortable, and I want to say it before the disclaimers, before the caveats, before the politely worded softening that usually surrounds this kind of statement. Here it is: I am sorry, but no. Neural networks are not capable of real, genuine, fully autonomous intelligence, and I need you to sit with that sentence for a moment before you start typing your rebuttal. I said genuine intelligence. Not artificial intelligence, not useful intelligence, not impressive intelligence. Genuine. That word is doing enormous work in that sentence, and I chose it with the same care I choose every other word I write. In my previous post &lt;a href="https://dev.to/wiseai/genuine-intelligence-will-never-in-trillion-years-emerge-from-neural-networks-1250"&gt;Genuine Intelligence will never in trillion years emerge from neural networks&lt;/a&gt;, I laid out the architectural argument from first principles. In &lt;a href="https://dev.to/wiseai/all-you-have-access-to-is-knowledge-and-tools-never-intelligence-5792"&gt;All You Have Access To Is Knowledge and Tools; Never Intelligence!&lt;/a&gt;, I showed that the entire intelligence narrative built around current AI systems is a category error dressed up in venture capital language. In &lt;a href="https://dev.to/wiseai/knowledge-and-intelligence-are-mutually-exclusive-kd4"&gt;Knowledge and Intelligence ARE Mutually Exclusive&lt;/a&gt;, I pushed that argument further. In this post I am going to go one more step, because something has shifted in the public conversation recently that requires a direct and unapologetic response, and I am the person who is apparently going to give it.&lt;/p&gt;

&lt;p&gt;The shift I am talking about is the following. A few months ago, the AI discourse was dominated by claims about language model reasoning. Before that it was claims about emergent capabilities. Before that it was claims about few-shot generalization. Each cycle, a new capability gets announced with increasing breathlessness, a new wave of LinkedIn posts declares that the singularity is here, and then 6 months later the researchers publish the papers showing what was actually happening under the hood, and it was pattern matching again. This cycle has been running for years. What is different now is that the current claims have escalated to the level of full autonomy. The claim is no longer that models can reason; the claim is that models are fully autonomous agents that can conduct scientific research, develop software, run business operations, and govern themselves without meaningful human oversight. And I need to explain, carefully and without being polite about it, why that claim is not just premature but structurally impossible given what neural networks actually are. Not impossible because the technology needs more time. Impossible because the mechanism is wrong. The same way a bicycle is structurally impossible to fly regardless of how technically refined it becomes, because the mechanism of a bicycle is not the mechanism of flight.&lt;/p&gt;

&lt;p&gt;I also want to say something before we go further about the phrase genuine autonomy, because I am using it in a specific and demanding sense and I want to be honest about what that sense is. Genuine autonomy means the capacity to set one's own goals, to evaluate the quality of one's own reasoning, to identify when one's own knowledge is insufficient, to decide what new knowledge to seek and how to seek it, to operate across novel domains that were not anticipated during design, and to do all of this without requiring a human at the end of the decision chain to validate, redirect, or supervise the process. That is the bar. It is a high bar. It is also the bar that every serious definition of autonomous agency sets, and it is the bar that current AI systems, regardless of wrapper, do not reach and cannot reach with the current architecture. I am going to spend the rest of this post explaining why with some humor because otherwise I would lose my mind, and with the same directness that I used in every post before this one.&lt;/p&gt;

&lt;h2&gt;
  
  
  Wait, What Do You Mean By Genuine Intelligence vs Genuine Artificial Intelligence?
&lt;/h2&gt;

&lt;p&gt;I know the first objection coming, and I want to cut it off before it finishes forming. You are about to tell me that I am splitting linguistic hairs. You are about to say that the distinction between genuine intelligence and genuine artificial intelligence is just a semantic game, a rhetorical move that lets me redefine my terms whenever the AI does something impressive. I want to tell you no, and I want to tell you why. The distinction is not about semantics. It is about mechanism, and mechanism is the thing that determines what a system can and cannot do regardless of how impressive it looks from the outside. Genuine artificial intelligence, in the sense the term has been used since the 1950s, means systems that can mimic intelligent behavior. Artificial is the key word. The intelligence is a mimicry, an artifact, something made to resemble intelligence rather than something that is intelligence. We have had genuine artificial intelligence since GPT-1. The models predict plausible, contextually appropriate text. That is a form of artificial intelligence. It is impressive, it is useful, and nobody should pretend otherwise.&lt;/p&gt;

&lt;p&gt;Genuine intelligence, without the artificial qualifier, means something categorically different. It means the capacity to understand the world as it is rather than as it was described in the training data. It means the capacity to form new concepts from first principles rather than recombining concepts that were absorbed during training. It means the capacity to be wrong in a productive way, to notice the wrongness, to investigate it, to generate a hypothesis about why, to test that hypothesis against reality, and to update. It means the capacity to function in genuinely novel domains with no prior training context for that domain. A 12 year-old human child has genuine intelligence in this sense. The child can walk into an unfamiliar situation, form a model of what is happening, make predictions, get corrected by reality, and update their model. They do not need a training set for every new situation. They need the general capacity for model formation and causal reasoning, which develops through embodied experience in the physical world and which no transformer architecture produces through text prediction. The difference between these two kinds of intelligence is not a matter of degree. It is a matter of kind, and collapsing that distinction is how we end up with billion-dollar systems that confidently hallucinate medical diagnoses.&lt;/p&gt;

&lt;p&gt;I also want to address the specific version of the objection that says intelligence is a spectrum and the models are somewhere on it. This objection sounds measured and scientifically responsible, but it contains a hidden assumption that I reject, which is that the mechanisms of human intelligence and the mechanisms of neural network prediction are the same mechanism operating at different intensities. They are not. They are different mechanisms. A thermometer measures temperature in a way that is mechanistically completely different from how your body feels temperature. A photograph of a landscape is mechanistically completely different from a painting of the same landscape. Both the thermometer and your skin produce a response that covaries with temperature, but one is an engineered measurement and the other is a felt experience rooted in biology, and they are not on the same spectrum. Similarly, a language model produces outputs that covary with intelligent human outputs because it was trained to do so, but the process producing those outputs is mechanistically different from the process producing human intelligence, and being on a similar output spectrum does not make them the same kind of thing (1). The history of AI is full of systems that produced outputs indistinguishable from intelligent behavior on narrow tasks and then failed completely when the task changed even slightly. That failure is the signature of a mechanism mismatch, not a capability gap that will close with scale.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ffzste65nx99bg7ovhgxv.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ffzste65nx99bg7ovhgxv.gif" alt="Explaining the difference between genuine and artificial intelligence to a tech bro" width="260" height="260"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The practical dimension of this distinction matters enormously and is not being discussed honestly in the public conversation. When companies deploy systems as autonomous agents and claim those systems are genuinely intelligent, they are making an implicit promise about the range of conditions under which those systems will perform reliably. Genuine intelligence implies robustness across novel conditions. Artificial intelligence implies reliable performance within the training distribution. Those promises are completely different in scope, and the gap between them is where people get hurt. A system that is genuinely autonomous can be trusted to handle situations that were not anticipated during design. A system that mimics autonomy can only be trusted to handle situations that are close to what it was trained on, which is a critically different trust relationship, and conflating them is how we end up with autonomous vehicles that fail in light rain, autonomous medical advisory systems that fail with unusual patient presentations, and autonomous coding agents that confidently introduce security vulnerabilities that no human reviewer would miss. The linguistic distinction between genuine and artificial intelligence is not a game. It is the most practically important distinction in the entire field.&lt;/p&gt;

&lt;h2&gt;
  
  
  But OpenAI Just Solved Mathematics, So Checkmate?
&lt;/h2&gt;

&lt;p&gt;Deep breath. Deep breath. Okay. Let me say this as kindly as I can manage, which is not very kindly. I already wrote about this general category of result in multiple previous posts and predicted it would happen, which means the result was not surprising to me, and I want to explain exactly why it should not be surprising to anyone who has been paying attention. A model trained on the entirety of human mathematical knowledge, which includes not just the correct theorems but the failed proofs, the partially solved problems, the heuristics, the analogies, the researcher notes, the textbook exercises, the competition problems, and the entire corpus of mathematical reasoning as expressed by humans over several centuries, that model generating solutions to problems that were previously unsolved is expected. I did not say it is unimpressive. I said it is expected. There is a difference, and the difference matters for what we conclude from it.&lt;/p&gt;

&lt;p&gt;The Navier-Stokes problem is a genuinely hard mathematical problem. Let nobody suggest I am dismissing its difficulty or its importance. But the way the model approaches a hard mathematical problem is not the way a mathematician approaches a hard mathematical problem. A mathematician builds a conceptual model of the problem space, identifies the structural feature that makes the problem hard, looks for analogies in other areas of mathematics that share that structural feature, formulates a hypothesis about what kind of argument strategy might work, explores that strategy, gets stuck, backtracks, reformulates, and eventually either succeeds or concludes that the approach was wrong. That process is generative intelligence operating on a causal model of the mathematical structure. What the model does is something statistically similar to pattern completion over a learned representation of mathematical text, and the fact that this can sometimes produce correct proofs for previously unsolved problems is remarkable but it is not evidence of genuine mathematical intelligence any more than a sufficiently detailed weather simulation is evidence that the simulation understands meteorology (2). The simulation produces correct predictions. It does not understand. The model produces correct proofs. It does not understand. These are not the same thing.&lt;/p&gt;

&lt;p&gt;I also want to say something about the specific framing of "OpenAI has solved mathematics" that appears in every breathless tech news headline when one of these results drops. Mathematics is not a set of problems to be solved. Mathematics is a living, generative discipline that creates new problems faster than it solves old ones, because in mathematics the solution to a problem almost always reveals new structure that opens 10 harder problems. The Mossad agents who normally help me with my architectural decisions apparently also help me with my epistemology, and they would point out that the interesting question is not whether the model can solve the existing unsolved problems but whether the model can formulate new problems that reveal new mathematical structure. Chollet argued in his landmark paper on measuring intelligence that skill acquired through training is fundamentally different from the fluid intelligence required to form entirely new problems, and that metrics which reward skill without measuring generalization ability give a systematically misleading picture of what a system can do (3). Ramanujan did not solve existing problems. He discovered entire new areas of mathematical structure that nobody had imagined. A language model trained on Ramanujan's work can reproduce patterns from his work. It cannot be Ramanujan.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F14hqm4zw37h07pzgilin.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F14hqm4zw37h07pzgilin.jpeg" alt="Bro be tryna explain to the press that solving an existing problem is not the same as discovering a new field of mathematics" width="667" height="500"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The pollution dimension of this situation also deserves explicit attention, because it is already happening and its consequences are already visible. As AI companies race to demonstrate mathematical or scientific capability, they are flooding academic preprint servers and research journals with AI-generated content at a rate that exceeds the human capacity for review and evaluation. The result is not an acceleration of scientific knowledge. The result is an acceleration of scientific content, which is a different and far more dangerous thing. Scientific content without the verification, the debate, the failed replication attempts, the collegial argument that slowly separates the genuine advance from the plausible-sounding error, that content is not science. It is noise that looks like science, and it degrades the ability of the research community to identify and build on genuine advances. I wrote in &lt;a href="https://dev.to/wiseai/llms-destroyed-the-internet-lmms-will-make-it-alive-1fbk"&gt;LLMs destroyed the Internet. LMMs will make it alive&lt;/a&gt; about how automated content generation destroys the epistemic value of the information environment. The same dynamic is now operating in the scientific literature, and the long-term cost is the trustworthiness of science itself. Nobody is excited. Nobody is shocked. And nobody should be, because this was predictable.&lt;/p&gt;

&lt;p&gt;I want to also directly address the human dimension of this, because I think it gets lost in the excitement over capability demonstrations. We human beings value effort not as a quirk of our psychology but because effort is the mechanism by which understanding is produced. The struggle to solve a hard problem, the years of failed attempts, the moments of insight that feel like gifts because they follow months of fruitless work, those are not inefficiencies to be optimized away. They are the process by which a human mind builds a deep causal model of a problem domain. When a system produces a solution without that struggle, the solution may be correct but it is also orphaned. It has no parent understanding. Nobody who holds that solution knows why it works in a deep enough sense to know where to go next. This is the reason that human mathematicians are, almost universally, not excited about AI-generated proofs. The proof is not the point. The understanding that the proof reveals is the point. A proof you did not struggle to find is a solution to a crossword puzzle completed by someone else. You have the answer. You do not have the understanding. And in mathematics, as in everything that actually matters, the understanding is the whole game.&lt;/p&gt;

&lt;h2&gt;
  
  
  But GPT-N Omega Pro Max++ Vibe-Coded This Entire Game Fully Autonomously?
&lt;/h2&gt;

&lt;p&gt;Here we go. Let me compose myself. Okay. I am composed. This argument comes up constantly now, and it follows the same template every time. An AI model, usually labeled with some impressive name involving a high number or a Greek letter, produces a functional artifact, usually a game, a website, or a piece of software, without explicit human instruction at the code level, and the result is presented as evidence of autonomous creativity and genuine intelligence. I need to take this apart, carefully and without losing my temper, because the argument is seductive and the counterargument requires more than a sentence to deliver properly. So let us be thorough about it.&lt;/p&gt;

&lt;p&gt;The first thing to understand about a model generating a functional game autonomously is what the word generating means in this context. The model does not create the game the way a human game developer creates a game. A human game developer starts with a vision, an aesthetic, a set of mechanics, a world, a set of rules that interact in interesting ways, and then implements all of that through a sequence of design and engineering decisions that each encode an aspect of the original vision. The interesting part is not the code. The interesting part is the creative vision that the code expresses. A language model generating a game produces code that is a collage of patterns from similar games in its training data, recombined in ways that happen to produce a functional result. The result may run correctly. It does not express a creative vision, because the model has no communicative intent, no aesthetic intention, no sense of what would be interesting or meaningful to a player. Bender et al. argued precisely this in their foundational critique of large language models: that these systems are stochastic parrots producing form without meaning, statistical mirrors of human text that carry none of the communicative intent that makes human language meaningful (4). It has learned what game code looks like, and it produces something that fits that learned distribution.&lt;/p&gt;

&lt;p&gt;The second thing to understand is that nobody wants to play the game. And this is not a small point. This is the entire point. A game's value to a player is not its technical correctness. A game's value is its soul, its lore, its narrative, its sense of humor, its respect for the player's time and intelligence, and above all its feeling of having been made by someone who cared about the experience of playing it. These are properties that I can detect immediately when I pick up a game, and so can you, even if you cannot articulate them precisely. When someone tells you that an LLM generated this entire game, something in you deflates, and that deflation is not irrational. It is a recognition that the thing is a hollow artifact. It runs, but nobody meant it. And meaning is not an optional luxury feature of creative work. Meaning is the entire reason creative work has value to the people who experience it. A game without meaning is just a physics engine with textures. You would get more out of asking the LLM to live-stream a playthrough of the game for you on the fly, which the LLM can do, and which would be more interesting to watch than playing a game that nobody genuinely imagined.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgs8bjwzrzli5ha4l40gh.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgs8bjwzrzli5ha4l40gh.jpeg" alt="My Genuine reaction after downloading a fully AI-generated indie game." width="515" height="388"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The third thing to understand is the structural incompleteness of what gets described as fully autonomous generation. What the model actually did in every documented case of this type, when you look at the methodology rather than the marketing, is generate a frontend scaffold for a simple game loop, using patterns from similar open-source games in its training data. The complete experience of a game in the real world involves enormously more infrastructure than a scaffold. It involves backend services, matchmaking systems, chat infrastructure, anti-cheat systems, persistent player state, telemetry, analytics, abuse reporting, content moderation, accessibility features, localization, monetization systems, third-party service integrations, compliance with platform policies, and decades of iterative refinement based on player feedback. None of that exists in the autonomously generated output. What exists is a proof of concept that demonstrates the model can produce code that resembles the code of games it was trained on. Calling that full autonomous game development is like calling a photograph of a house the house. The photograph is an artifact that references the structure. The model output is an artifact that references the functionality. Neither of them are the thing itself.&lt;/p&gt;

&lt;p&gt;I also want to say something about the direction this argument is going, because I see it more and more: the claim that because the model can produce the surface form of creative work, the model is producing creative work, that because it can generate code that compiles, it is doing software engineering, that because it can write a sentence that is grammatically complex, it is engaging in literary expression. This is the philosopher's zombie problem applied to AI, and I want to name it clearly. A philosophical zombie, in thought experiment form, is an entity that behaves exactly like a conscious being in every observable respect but has no inner experience of that behavior. The behavior is there. The inner life is not. Current AI systems are philosophical zombies of intelligence. They produce the behavioral outputs associated with intelligence. The inner process producing those outputs is pattern completion over a learned statistical distribution, not reasoning, not understanding, not intention, not creativity. And a zombie playing chess is not a chess player. It is a zombie that makes moves. The distinction matters for what you trust the zombie to do next.&lt;/p&gt;

&lt;h2&gt;
  
  
  What LLMs Are Actually Doing, and Why It Is Just The Tip of The Iceberg
&lt;/h2&gt;

&lt;p&gt;I want to be fair here, because I have been consistently fair in every post I have written, even when the thing I am being fair about is something that is actively used to argue against positions I hold. LLMs are powerful. They are more powerful than most people thought possible five years ago. They are useful, they are economically valuable, and the scale of what they can do within their training distribution is genuinely impressive. I wrote all of that in &lt;a href="https://dev.to/wiseai/llms-are-usefull-lmms-will-break-reality-8an"&gt;LLMs are Usefull. LMMs will Break Reality&lt;/a&gt;, and I stand by every word of it. But power within a training distribution is not the same as autonomy, and the gap between what LLMs can do and what production systems require is not a gap that can be bridged by wrapping the model in a better API.&lt;/p&gt;

&lt;p&gt;Think of a language model as a very sophisticated for-loop with memory. At each step, the loop looks at the current context, applies a search over the learned representation space, samples from the resulting distribution using some randomness to prevent deterministic collapse, and appends the result to the context before running the next iteration. That is a real and powerful computation. It is also a computation that is entirely reactive. It does not initiate. It does not plan beyond the immediate token horizon. It does not build a model of what it is trying to accomplish and monitor the gap between that model and the current state. It responds to input with statistically appropriate output. This is enormously useful for code completion, for document summarization, for information synthesis, for translation. It is not autonomous operation. Shanahan, in his careful philosophical treatment of what it means to talk about large language models honestly, argues that the anthropomorphism enabled by LLMs' fluency in human language makes us systematically vulnerable to describing them in terms that do not match their actual mechanism, and that repeated stepping back to ask what the system actually does will almost always reveal a reactive prediction engine rather than a reasoning actor (5).&lt;/p&gt;

&lt;p&gt;The production software systems that people actually run in the real world are not merely frontend scaffolds. They are layered stacks of interacting subsystems, each with its own failure modes, its own performance characteristics, its own operational requirements, and its own behavioral contracts with the other subsystems. A game on a real production platform has a game server cluster, a matchmaking service, a leaderboard service, a player identity and authentication service, a database cluster with replicas and backup procedures, a CDN for asset delivery, a monitoring and alerting stack, a deployment pipeline, a rollback procedure, a DDoS mitigation layer, and usually somewhere between three and five third-party service integrations that each have their own documentation, API limits, and failure behaviors. The model that generated the game frontend has no knowledge of any of this beyond the surface patterns it absorbed from documentation text in its training data. Building production systems is an exercise in understanding the mechanisms of failure across a complex interacting set of subsystems, and understanding failure mechanisms requires causal models that no language model has (6).&lt;/p&gt;

&lt;p&gt;The voice chat room in an online game is not a text generation problem. The latency constraints, the packet loss handling, the codec selection, the server-side mixing, the abuse detection in audio streams, the GDPR compliance for voice data, the integration with the client application, the regional routing for low latency, none of these are problems that get solved by generating plausible-sounding text about how voice chat would look. They are engineering problems that require deep understanding of network protocols, audio signal processing, distributed systems, regulatory frameworks, and the specific constraints of the game's platform and user base. The autonomously generated game has none of that. It has a textbox. And a textbox is not a voice chat room, no matter how many parameters the model that generated it has. This is not a criticism of the model. It is a description of what the model is and is not, and what production software is and is not, and why those two things are not the same.&lt;/p&gt;

&lt;p&gt;I want to connect this to something I said in &lt;a href="https://dev.to/wiseai/all-you-have-access-to-is-knowledge-and-tools-never-intelligence-5792"&gt;All You Have Access To Is Knowledge and Tools; Never Intelligence!&lt;/a&gt; about the frame problem. The frame problem, in practical engineering terms, is the problem of knowing which things change when you take an action and which things do not. When you deploy a new version of a service, what changes is the behavior of that service. What must not change, if you want your system to continue working, is the behavioral contracts between that service and everything it interacts with. Managing those contracts, reasoning about what is downstream of what, identifying which changes are safe and which are breaking, that is the daily work of a software engineer operating in a production system. It requires a causal model of the system. It requires the capacity to simulate what will happen when a change propagates through a layered stack of interacting services. A language model can produce code that looks like service code. It cannot reason causally about what will happen when that code runs in the production system, because it does not have a causal model of the production system. It has text about systems that look similar. That is the tip of the iceberg. The iceberg is everything that the text does not capture, and in production engineering, the iceberg is where ninety percent of the work lives.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Autonomy Illusion: How Wrappers Become Worldviews
&lt;/h2&gt;

&lt;p&gt;One of the most sophisticated-sounding arguments for AI autonomy goes like this: yes, the model itself is just pattern completion, but wrap it in the right scaffolding, give it memory, give it tools, give it the ability to call itself recursively, and you get something that is functionally autonomous even if the underlying mechanism is not. I hear this argument a lot from people who are technically sophisticated, and I want to engage with it honestly because it deserves engagement rather than dismissal. The argument is not crazy. There are systems architectures where simple computational units combine into systems with properties that no individual unit has. Neurons are simple threshold devices. Brains compute extraordinarily complex things. So why can't a simple language model plus scaffolding produce genuine autonomy?&lt;/p&gt;

&lt;p&gt;The answer is that the brain analogy fails at the level of mechanism, and mechanism is the thing that matters. Neurons combined into brains produce intelligence because the combination instantiates specific computational structures, specifically causal inference over hierarchical generative models, that are capable of producing genuine reasoning, genuine model formation, and genuine updating in response to prediction error (7). The computation is grounded in physical reality through sensorimotor experience that provides labeled prediction errors across millions of daily interactions. The structural organization of the brain, the cortical hierarchy, the basal ganglia, the hippocampal memory systems, the thalamic gating, is specifically adapted over millions of years of evolution to produce the kind of learning and inference that counts as intelligence. Wrapping a language model in scaffolding and memory does not replicate any of this. It adds a context management layer on top of a reactive prediction system. The scaffolding does not change what happens inside the prediction step, and the inside is where the intelligence would have to live.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fe2las4tcsxyeaekjx8s9.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fe2las4tcsxyeaekjx8s9.jpeg" alt="The AI agent architecture diagram looking incredibly impressive." width="622" height="402"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Memory does not solve the problem. Memory gives the model access to more text context. But having access to more text does not produce causal reasoning from that text. It produces pattern completion over more text. A model with a million-token context window is not more intelligent than a model with a four-thousand-token context window. It has more information available for its pattern completion. That is a real and useful improvement. It is not a mechanism for producing genuine reasoning, because the mechanism producing the output at each step is still pattern completion, regardless of how much context is available to that step (8). A person who reads more books is not smarter than a person who reads fewer books in any direct proportional sense. A person who reads more books has more raw material for their intelligence to work with. The intelligence doing the working is not in the books. It is in the cognitive architecture that was shaped by evolution and development long before the first book was opened.&lt;/p&gt;

&lt;p&gt;Tool use does not solve the problem either, and I made this argument at length in &lt;a href="https://dev.to/wiseai/all-you-have-access-to-is-knowledge-and-tools-never-intelligence-5792"&gt;All You Have Access To Is Knowledge and Tools; Never Intelligence!&lt;/a&gt;. A language model that can call a calculator, a search engine, and a code interpreter is a language model plus three lookup operations. The intelligence required to know which tool to use in which situation, to interpret what the tool returns, to integrate the tool output with the rest of the reasoning context, that intelligence has to live somewhere. And in the agentic architecture, the place it is supposed to live is the language model. But the language model's behavior in that role is still pattern completion over training data about how agents use tools, not genuine reasoning about which tool is appropriate for the current problem. The result is that the tool-augmented agent fails in characteristic pattern-matching ways on novel tool usage situations, which is exactly what the research shows (9). You can add recursion too. The model can call itself repeatedly, reflecting on its own output, generating a chain of self-assessments. But each step in that chain is still a pattern completion step, and a chain of pattern completion steps is not reasoning any more than a chain of coin flips is a decision. The appearance of self-reflection does not instantiate self-reflection.&lt;/p&gt;

&lt;p&gt;Genuine autonomy requires something that none of these scaffolding additions provide, which is an internal model of the task that allows the system to distinguish between situations where the current approach is working and situations where the current approach is failing, and to adaptively switch strategies based on that distinction. That is meta-cognitive control, the ability to monitor the quality of one's own cognitive processes and to intervene when quality is insufficient. Research on human metacognition has established that this capacity develops through years of embodied feedback, through the experience of trying, failing, noticing the failure, trying differently, and building a model of one's own cognitive strengths and weaknesses in specific domains. Language models have a statistical approximation of metacognitive language, they can produce text that sounds like self-assessment. They do not have the underlying process, the monitored internal model that the self-assessment text is supposed to describe. The words are there. The referent is not. And an autonomous agent without genuine metacognitive control is not an autonomous agent. It is a system that will continue confidently in the wrong direction for as long as the statistical distribution of its training data supports doing so.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Research Nobody Wants to Read But Everybody Should
&lt;/h2&gt;

&lt;p&gt;I want to spend time in this section on the empirical evidence, because I believe strongly that the argument I am making is not just philosophically sound but empirically grounded in a body of research that is not making it into the popular conversation with the prominence it deserves. The popular conversation about AI capability is substantially driven by benchmark performance announcements, demo videos, and press releases. The empirical research literature on what AI systems cannot do is substantially less visible. That asymmetry is not neutral. It shapes what people believe about the current state and trajectory of AI, and beliefs shape decisions, and decisions about AI deployment have real consequences for real people.&lt;/p&gt;

&lt;p&gt;The research on AI agent reliability is the most directly relevant to the autonomy question, and the results are unambiguous. Kambhampati et al. demonstrated from first principles that auto-regressive LLMs cannot, by themselves, perform sound planning or self-verification, because the next-token prediction mechanism does not implement the look-ahead and backtracking required for global goal alignment (9). This theoretical argument is validated empirically in large-scale agent benchmarks: the WebArena evaluation placed state-of-the-art GPT-4-based agents on realistic long-horizon web tasks and measured a task success rate of only 14.41 percent against a human success rate of 78.24 percent, representing failure rates exceeding eighty-five percent on tasks that a capable human completes routinely (10). The failure modes are consistent and predictable: agents take locally plausible actions that compound into globally incorrect outcomes, and when they encounter situations that do not match their training distribution, they either fail to recognize the mismatch or continue confidently toward the wrong outcome. These are not random failures. They are the systematic signature of a system that lacks a global model of the task and is therefore unable to detect when the local action is inconsistent with the global goal. A genuinely autonomous system would detect this inconsistency and recover. A pattern-matching system cannot, because detecting the inconsistency requires comparing the current state against a model of the intended state, and that kind of model-based comparison is not what pattern completion produces.&lt;/p&gt;

&lt;p&gt;The research on distribution shift, which I discussed in &lt;a href="https://dev.to/wiseai/genuine-intelligence-will-never-in-trillion-years-emerge-from-neural-networks-1250"&gt;Genuine Intelligence will never in trillion years emerge from neural networks&lt;/a&gt;, has continued to accumulate in the same direction. Study after study finds that AI systems perform reliably within their training distribution and unreliably outside it, and the performance degradation is dramatic rather than gradual. Taori et al. systematically evaluated 204 ImageNet classification models across 213 different test conditions and found that robustness gains from synthetic perturbation training rarely transferred to natural distribution shifts, and that virtually no existing technique fully closes the performance gap between in-distribution and naturally shifted test sets (11). This is the canonical signature of a system that has learned to exploit statistical regularities in the training data rather than learning the underlying rule that generates the data, and it appears consistently across architectures, scales, and domains. It does not go away with more scale. It changes in its specific manifestations as the model becomes more capable within its distribution, but the structural incompatibility between pattern matching and genuine generalization remains. More impressive pattern matching is still pattern matching, and pattern matching does not become autonomy at any scale.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxdulczjgyaueavzvultl.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxdulczjgyaueavzvultl.jpeg" alt="Research paper that proves LLMs are pattern matchers appearing in the preprint server." width="637" height="392"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The research on AI in high-stakes professional domains is perhaps the most concrete evidence of the autonomy gap, because these are exactly the domains where genuine autonomy would be most valuable and where its absence is most costly. Obermeyer et al. conducted a landmark analysis of a commercial health-management algorithm and found that it systematically underestimated the health needs of Black patients because it used healthcare cost as a proxy for health need, encoding the structural reality that Black patients had less access to care into a learned bias that treated them as healthier than equally sick White patients (12). The algorithm was not doing medicine. It was doing pattern matching over a dataset where the patterns encoded centuries of unequal access. A genuinely autonomous medical reasoner, one operating from a causal model of pathophysiology, would not confuse spending patterns with health status. A pattern-matching system cannot distinguish between them, because in its training data, they covary, and covariation is all it can learn. The bias shows up not as a subtle statistical artefact but as a systematic, measurable failure that affects real patients in real clinical settings, and it is invisible to the system producing it because the system has no model of the mechanism generating the pattern.&lt;/p&gt;

&lt;p&gt;The research on AI legal reasoning has found similar patterns. Dahl et al. conducted the first systematic profiling of legal hallucinations in large language models and found that legal hallucinations were alarmingly prevalent, occurring between 58 percent of the time with GPT-4 and 88 percent of the time with Llama 2 when models were asked specific, verifiable questions about federal court cases (13). The model that passes the bar examination has learned the statistical distribution of bar examination questions, which is a specific and relatively well-defined distribution that diligent pattern matching can handle. But when the same model is asked to retrieve or reason about actual legal specifics, specific case names, specific holdings, specific statutes in specific jurisdictions applied to specific novel fact patterns, it confabulates with high confidence, because the specific combination has no reliable match in the training distribution and the model has no actual model of legal structure to reason from. Dahl et al. also found that LLMs often cannot correct a user's incorrect legal assumptions, and frequently do not know when they are producing a hallucination, which is the overconfidence signature in its most dangerous possible form. This is happening in systems already deployed in real legal contexts, serving real clients.&lt;/p&gt;

&lt;h2&gt;
  
  
  Genuine Intelligence Requires Genuine Grounding, and That Grounding Cannot Be Simulated in Tokens
&lt;/h2&gt;

&lt;p&gt;There is a philosophical concept called grounding and it explains a great deal about why text-trained models cannot achieve genuine autonomy. Grounding refers to the connection between a symbol and the thing in the world that the symbol refers to. When I use the word hot, my use of that word is grounded in my experience of touching hot surfaces, of feeling the burns, the warmth, the danger signal, the automatic withdrawal reflex. That experience is what gives the word hot a meaning that goes beyond its statistical relationship with other words. A language model's use of the word hot is statistically associated with other words like fire, pain, temperature, summer, and coffee, and that statistical association allows it to produce contextually appropriate text involving the word hot. But the word is not grounded in any felt experience of heat. It is an ungrounded symbol, and ungrounded symbols cannot support genuine reasoning about the referents of those symbols in the way that grounded symbols can (14).&lt;/p&gt;

&lt;p&gt;The grounding problem is not merely philosophical. It has direct practical consequences that show up in specific failure modes. A model with ungrounded symbols cannot reason about physical interactions in novel situations because its knowledge of physical interactions is stored as statistical associations between words that describe physical interactions, not as a model of the physics itself. Ask the model to predict what will happen when you drop a cube of ice into a glass of warm water, and it will produce the correct answer because that scenario is well-represented in its training data. Ask it to predict what will happen when you drop a specific non-standard material with specific non-standard thermodynamic properties into a specific non-standard fluid under non-standard pressure, and it will confabulate, because the specific combination has no statistical precursor in the training data and the model has no actual physical simulation to fall back on. A genuinely intelligent system would use its physical model, its understanding of thermodynamics, to compute the answer for any combination of materials and conditions. The model uses its training data, which means it only knows what it has been told about specific scenarios. And there are infinitely many specific scenarios that nobody has written text about.&lt;/p&gt;

&lt;p&gt;The solution to the grounding problem is not more text. More text does not ground symbols in physical reality. More text gives you more ungrounded symbols with richer statistical relationships to each other. A model trained on every physics textbook ever written has abundant statistical associations between physics words. It does not have a single simulation of a physical process grounded in the actual dynamics of the physical world. This is why I have argued across multiple posts for the importance of mathematical models and physics simulations as the alternative architecture. &lt;a href="https://dev.to/wiseai/mathematical-equations-are-multimodal-by-default-53fk"&gt;Mathematical Equations are Multimodal by default&lt;/a&gt; describes why equations are more honest representations of physical reality than text, because equations encode the mechanism rather than a description of the mechanism, and mechanisms are what ground the predictions in reality. A model built around equation discovery and physical simulation has symbols that are grounded in the dynamics of physical reality. A language model has symbols grounded only in other text. The first kind of grounding supports genuine reasoning about novel physical situations. The second kind supports sophisticated text generation about familiar textual patterns. Those are not the same capability.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fr9xmb4mwtglwuzmiaytv.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fr9xmb4mwtglwuzmiaytv.jpeg" alt="A philosophical zombie" width="800" height="857"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Embodied cognition research has established over the past three decades that human intelligence is not separable from the body that hosts it and the physical world that the body interacts with (16). When you understand what it means to grasp something, that understanding is rooted in the sensorimotor experience of grasping, the feel of fingers closing, the resistance of the object, the proprioceptive sense of hand position and grip strength. Your understanding of the abstract concept grasping a concept is a metaphorical extension of that embodied experience, and research shows that even processing abstract language activates sensorimotor neural systems involved in the corresponding physical actions. Intelligence is not a disembodied computation over abstract symbols. It is a computation deeply intertwined with a physical body that experiences the world and updates its models on the basis of that experience. Language models, by design, have no body, no sensorimotor experience, no felt consequences for wrong predictions, and no physical world to update against. They have text. Text is a description of embodied experience. A description of embodied experience is not the same as embodied experience, and intelligence built on descriptions cannot do what intelligence built on experience can do.&lt;/p&gt;

&lt;p&gt;I want to close this section by saying something about what genuine grounding would require that I think is underappreciated. Genuine grounding requires not just sensory data but the feedback loop between predictions and their consequences. It requires a system that has made predictions about the physical world and had those predictions either confirmed or disconfirmed by events in that physical world, and that has updated its internal model on the basis of that feedback. This is the reinforcement learning setup in its genuine sense, not the RLHF approximation that is used to fine-tune language models, but actual reinforcement learning where the signal comes from the physical world. Reinforcement learning in that genuine sense can produce grounded representations of the world, as demonstrated by robotics systems and simulation-trained physical agents. But those systems are not language models. They are a different architecture solving a fundamentally different problem. And the intelligence produced by genuine reinforcement learning against physical reality does not transfer from the language model paradigm regardless of how large the language model becomes.&lt;/p&gt;

&lt;h2&gt;
  
  
  We Do Not Even Know What We Do Not Know, and That Is the Real Problem
&lt;/h2&gt;

&lt;p&gt;One of the most dangerous properties of current AI systems in deployment is the combination of high capability within the training distribution and high confidence everywhere. The system does not degrade gracefully as it approaches the edge of its competence. It falls off a cliff while still sounding absolutely certain. This is the property that I find most troubling about the current deployment environment, more troubling than any specific failure mode, because it makes the failures unpredictable and therefore unmanageable. If a system degraded gracefully and signaled increasing uncertainty as it approached the edge of its competence, you could deploy it with appropriate monitoring and respond to the signals before the failures had consequences. But a system that fails while sounding confident fails silently, from the user's perspective, until the failure has already had consequences.&lt;/p&gt;

&lt;p&gt;Calibrated uncertainty, the property of knowing what you do not know, is a defining feature of genuine intelligence and a property that neural networks systematically lack in their base form. Guo et al. demonstrated in a foundational study of neural network calibration that modern deep neural networks are poorly calibrated compared to their predecessors, that they are systematically overconfident, and that this overconfidence grows with model depth, width, and the use of batch normalization, meaning that the architectural choices that make neural networks more accurate also make them more overconfident in their wrong answers (15). A model that has seen many confident-sounding statements in its training data will produce confident-sounding statements in contexts that resemble its training data, regardless of whether that confidence is warranted in the specific case. This is not a calibration bug that can be patched. It is a structural consequence of the training objective, which rewards producing confident predictions on training examples and has no direct mechanism to penalize overconfidence in the specific situations where the model's knowledge is weakest.&lt;/p&gt;

&lt;p&gt;The absence of genuine metacognitive monitoring is the root cause. A genuinely intelligent system would monitor the quality of its own reasoning, flag when it was operating in unfamiliar territory, and scale its expressed confidence to match its actual epistemic state. This kind of metacognitive monitoring is what humans call knowing what you know and knowing what you don't know, and while humans are imperfect at it, the basic capacity exists and can be trained and improved. In neural networks, the absence is architectural. The model produces its outputs through a single forward pass, without any separate process that monitors the quality of the reasoning or evaluates the confidence of the output against the strength of the evidence. Techniques like sampling-based uncertainty estimation give a proxy for disagreement between model samples, but that proxy is not the same as genuine metacognitive monitoring, and it does not prevent the confident production of confident-sounding wrong answers. The model does not know what it does not know because it does not have a model of what it knows. It has weights. Weights do not know things. They encode statistical associations, and statistical associations do not have an epistemic status that the model can introspect and evaluate.&lt;/p&gt;

&lt;p&gt;For a genuinely autonomous system, calibrated uncertainty is not optional. It is the mechanism by which an autonomous agent decides when to act on its own judgment and when to seek additional information, defer to a human, or flag a decision as requiring review. Without this mechanism, an autonomous agent will make high-stakes decisions in low-competence situations with the same apparent confidence as low-stakes decisions in high-competence situations, and the consequences of that cannot be managed at the deployment layer. You cannot fix a systematic overconfidence problem with monitoring alone, because the monitoring has to use the same system's outputs to assess the same system's confidence, and the system is wrong about its own confidence. This is the autonomy gap in its most concrete operational form. An autonomous vehicle that does not know where its competence ends is not safer than a human driver who does know where their competence ends. It is dramatically less safe. And scaling the model does not change the fundamental absence of the metacognitive architecture that would make it possible for the model to know what it does not know.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Would Genuine Autonomous Intelligence Actually Require?
&lt;/h2&gt;

&lt;p&gt;I want to be honest and constructive here because I have been making a primarily negative argument for most of this post and I genuinely believe in the possibility of building genuinely autonomous intelligent systems. I do not believe current neural networks can get us there. I believe the alternative direction exists and is the right one, and I want to describe it clearly. If you have read my previous posts, you have seen pieces of this argument scattered across multiple places. Here I want to assemble those pieces into a description of what the right architecture would need to look like.&lt;/p&gt;

&lt;p&gt;First, it would need causal modeling rather than statistical association. The difference is not subtle. A causal model of a domain represents the mechanisms that generate the observations, not just the statistical relationships between observations. A causal model of a medical domain would represent the biological mechanisms by which diseases produce symptoms, not the statistical correlation between symptoms and diagnoses in a training dataset. Causal models support genuine generalization because they generalize at the level of mechanism, which is domain-invariant, rather than at the level of surface patterns, which are training-distribution-specific. Judea Pearl's work on causal inference and the do-calculus provides the mathematical foundation for this, and the field of causal machine learning, while early stage, is producing real results (17). This is the right direction. It is also harder, slower, and less impressive in demos than scaling language models, which is why it is underfunded and understaffed relative to its importance.&lt;/p&gt;

&lt;p&gt;Second, it would need symbolic reasoning over learned representations, not just learned representations by themselves. Symbolic reasoning is what provides the truth-preserving inference rules that allow a genuine reasoner to derive new knowledge from known knowledge in ways that are reliable rather than statistically likely. The neurosymbolic research program, which I described in &lt;a href="https://dev.to/wiseai/genuine-intelligence-will-never-in-trillion-years-emerge-from-neural-networks-1250"&gt;Genuine Intelligence will never in trillion years emerge from neural networks&lt;/a&gt;, is the most promising approach here. It attempts to combine the representation learning strengths of neural networks with the structured inference strengths of symbolic systems. The engineering challenges are real but the theoretical case is solid. A system that can learn good representations from data and reason over those representations using principled inference rules would have systematic compositionality, would support genuine logical reasoning, and would avoid the surface-pattern dependence that characterizes pure neural approaches.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fykwsn5sh7yxwfdt9izx7.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fykwsn5sh7yxwfdt9izx7.gif" alt="Me tryna to explain to the average AI journalist" width="480" height="398"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Third, it would need physical grounding through interaction with the real world rather than text descriptions of the real world. This means some form of sensorimotor experience, either through robotics, through physics simulation with real physical fidelity, or through other forms of direct interaction with physical processes that produce genuine prediction errors when the system's model is wrong. The &lt;a href="https://github.com/wiseaidotdev/lmm" rel="noopener noreferrer"&gt;lmm project&lt;/a&gt; I have been building is an attempt to implement a piece of this, with symbolic regression for discovering physical equations from data rather than ingesting descriptions of physical equations from text. An LMM architecture that learns physical laws from measurements of physical processes has symbols grounded in physical reality in a way that a language model trained on text descriptions of physical laws does not. The grounding is genuine because the equations have been validated against real physical data, not because someone wrote down that the equations are valid.&lt;/p&gt;

&lt;p&gt;Fourth, it would need genuine metacognitive architecture, a separate process that monitors the quality of the primary reasoning process and has the authority to intervene, redirect, or flag uncertainty when warranted. This is not the same as adding a reflection step to the language model output. A reflection step is still a language model output, a pattern completion over descriptions of what good reflection looks like. A genuine metacognitive architecture is a separate computational process with a different objective from the primary reasoning process, specifically the objective of evaluating whether the primary reasoning is working and the objective of identifying when it is not. The computational structure for this exists in various proposals in the cognitive science and AI literature, and while no current system implements it in a satisfying way, it is a tractable engineering problem rather than an impossible one. The impossibility is not in building genuine metacognitive architecture. The impossibility is in producing genuine metacognition from a single-objective next-token prediction training process. You need to build the metacognitive capacity explicitly. It does not emerge from scale.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where Do We Go From Here, And What Honest Progress Looks Like
&lt;/h2&gt;

&lt;p&gt;I want to close this post the way I have closed every post before it, which is by saying something honest rather than something comfortable. The honest state of affairs is this: neural networks are extraordinarily powerful tools that operate within their training distributions with impressive and genuinely useful capability. They are not genuinely autonomous agents, they are not genuinely intelligent, and they will not become either of these things through further scaling of the same architecture. The gap between what they are and what genuine autonomous intelligence requires is architectural, not quantitative, and architectural gaps require different architectures, not more of the same architecture. This is not pessimism about AI. This is clarity about what the current tools are and a call for honesty about the gap between them and what we are claiming to build.&lt;/p&gt;

&lt;p&gt;The progress that would actually matter, the progress toward systems that can reason causally, that have grounded representations, that can generalize systematically, that know what they do not know, is happening in smaller research communities with less funding and less visibility than the communities building larger and larger language models. Causal machine learning, neurosymbolic AI, physics-informed learning, symbolic regression, embodied AI, all of these research directions are producing results that are more relevant to genuine autonomous intelligence than anything coming out of the scaling race, and they are producing those results with a fraction of the compute and a fraction of the investment. The academic incentive structure, the funding structure, and the media attention structure are all pointing in the wrong direction. The right direction is harder, slower, and does not produce demos that trend on social media. But it is the direction that leads somewhere real.&lt;/p&gt;

&lt;p&gt;For those of you who build things, which is most of the people I know and most of the people who read this blog, the honest implication of this argument is that you should use current AI tools for what they are good at, which is significant, and build your systems with appropriate understanding of where those tools fail. Do not build systems that depend on AI judgment in situations that fall outside the training distribution unless you have robust monitoring and human oversight for exactly those situations. Do not tell your users that your system is autonomous when it is a language model in a scheduling for-loop. Do not cite benchmark performance as evidence of real-world capability in novel domains. These are not technical requirements. They are honesty requirements. And honesty about what our tools can and cannot do is the minimum ethical obligation of anyone who builds and deploys systems that affect other people's lives.&lt;/p&gt;

&lt;p&gt;The future I want to build toward, and the one I am working on in my small way with the &lt;a href="https://github.com/wiseaidotdev/lmm" rel="noopener noreferrer"&gt;lmm project&lt;/a&gt;, is a future where artificial systems earn the word autonomous through demonstrated behavior in situations that were not anticipated during design. Not through impressive demo performance on curated benchmarks. Not through confident-sounding answers to questions that happen to be in-distribution. Through genuine generalization to genuine novelty, through honest uncertainty when facing unfamiliar territory, through the capacity to form new understanding rather than retrieve old patterns. That future is technically achievable. It requires different architecture, different training objectives, different evaluation criteria, and different honesty from everyone involved in building and deploying these systems. It also requires that we stop congratulating ourselves for the current tools as though they are already there, because they are not, and pretending otherwise is how we make the journey longer, not shorter.&lt;/p&gt;

&lt;p&gt;Till next time 👋!&lt;/p&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;p&gt;&lt;span id="ref-1"&gt;&lt;/span&gt;&lt;strong&gt;1.&lt;/strong&gt; Searle, J. R., &lt;em&gt;Minds, Brains, and Programs&lt;/em&gt;, &lt;a href="https://www.cambridge.org/core/journals/behavioral-and-brain-sciences/article/abs/minds-brains-and-programs/DC644B47A4299C637C89772FACC2706A" rel="noopener noreferrer"&gt;Behavioral and Brain Sciences, 1980&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-2"&gt;&lt;/span&gt;&lt;strong&gt;2.&lt;/strong&gt; Marcus, G. &amp;amp; Davis, E., &lt;em&gt;Rebooting AI: Building Artificial Intelligence We Can Trust&lt;/em&gt;, &lt;a href="https://www.penguinrandomhouse.com/books/603982/rebooting-ai-by-gary-marcus-and-ernest-davis" rel="noopener noreferrer"&gt;Pantheon Books, 2019&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-3"&gt;&lt;/span&gt;&lt;strong&gt;3.&lt;/strong&gt; Chollet, F., &lt;em&gt;On the Measure of Intelligence&lt;/em&gt;, &lt;a href="https://arxiv.org/abs/1911.01547" rel="noopener noreferrer"&gt;arXiv:1911.01547&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-4"&gt;&lt;/span&gt;&lt;strong&gt;4.&lt;/strong&gt; Bender, E. M., Gebru, T., McMillan-Major, A. &amp;amp; Shmitchell, S., &lt;em&gt;On the Dangers of Stochastic Parrots: Can Language Models Be Too Big?&lt;/em&gt;, &lt;a href="https://archive.org/details/stochastic-parrots-3442188.3445922" rel="noopener noreferrer"&gt;ACM FAccT 2021&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-5"&gt;&lt;/span&gt;&lt;strong&gt;5.&lt;/strong&gt; Shanahan, M., &lt;em&gt;Talking About Large Language Models&lt;/em&gt;, &lt;a href="https://arxiv.org/abs/2212.03551" rel="noopener noreferrer"&gt;arXiv:2212.03551&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-6"&gt;&lt;/span&gt;&lt;strong&gt;6.&lt;/strong&gt; Bommasani, R. et al., &lt;em&gt;On the Opportunities and Risks of Foundation Models&lt;/em&gt;, &lt;a href="https://arxiv.org/abs/2108.07258" rel="noopener noreferrer"&gt;arXiv:2108.07258&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-7"&gt;&lt;/span&gt;&lt;strong&gt;7.&lt;/strong&gt; Friston, K., &lt;em&gt;The free-energy principle: a unified brain theory?&lt;/em&gt;, &lt;a href="https://www.nature.com/articles/nrn2787" rel="noopener noreferrer"&gt;Nature Reviews Neuroscience, 2010&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-8"&gt;&lt;/span&gt;&lt;strong&gt;8.&lt;/strong&gt; Dziri, N. et al., &lt;em&gt;Faith and Fate: Limits of Transformers on Compositionality&lt;/em&gt;, &lt;a href="https://arxiv.org/abs/2305.18654" rel="noopener noreferrer"&gt;arXiv:2305.18654&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-9"&gt;&lt;/span&gt;&lt;strong&gt;9.&lt;/strong&gt; Kambhampati, S. et al., &lt;em&gt;LLMs Can't Plan, But Can Help Planning in LLM-Modulo Frameworks&lt;/em&gt;, &lt;a href="https://arxiv.org/abs/2402.01817" rel="noopener noreferrer"&gt;arXiv:2402.01817&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-10"&gt;&lt;/span&gt;&lt;strong&gt;10.&lt;/strong&gt; Zhou, S. et al., &lt;em&gt;WebArena: A Realistic Web Environment for Building Autonomous Agents&lt;/em&gt;, &lt;a href="https://arxiv.org/abs/2307.13854" rel="noopener noreferrer"&gt;arXiv:2307.13854&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-11"&gt;&lt;/span&gt;&lt;strong&gt;11.&lt;/strong&gt; Taori, R. et al., &lt;em&gt;Measuring Robustness to Natural Distribution Shifts in Image Classification&lt;/em&gt;, &lt;a href="https://arxiv.org/abs/2007.00644" rel="noopener noreferrer"&gt;arXiv:2007.00644&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-12"&gt;&lt;/span&gt;&lt;strong&gt;12.&lt;/strong&gt; Obermeyer, Z., Powers, B., Vogeli, C. &amp;amp; Mullainathan, S., &lt;em&gt;Dissecting racial bias in an algorithm used to manage the health of populations&lt;/em&gt;, &lt;a href="https://pubmed.ncbi.nlm.nih.gov/31649194/" rel="noopener noreferrer"&gt;Science, Vol. 366, 2019&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-13"&gt;&lt;/span&gt;&lt;strong&gt;13.&lt;/strong&gt; Dahl, M. et al., &lt;em&gt;Large Legal Fictions: Profiling Legal Hallucinations in Large Language Models&lt;/em&gt;, &lt;a href="https://arxiv.org/abs/2401.01301" rel="noopener noreferrer"&gt;arXiv:2401.01301&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-14"&gt;&lt;/span&gt;&lt;strong&gt;14.&lt;/strong&gt; Harnad, S., &lt;em&gt;The Symbol Grounding Problem&lt;/em&gt;, &lt;a href="https://arxiv.org/abs/cs/9906002" rel="noopener noreferrer"&gt;Physica D: Nonlinear Phenomena, 1990&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-15"&gt;&lt;/span&gt;&lt;strong&gt;15.&lt;/strong&gt; Guo, C. et al., &lt;em&gt;On Calibration of Modern Neural Networks&lt;/em&gt;, &lt;a href="https://arxiv.org/abs/1706.04599" rel="noopener noreferrer"&gt;ICML 2017&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-16"&gt;&lt;/span&gt;&lt;strong&gt;16.&lt;/strong&gt; Lakoff, G. &amp;amp; Johnson, M., &lt;em&gt;Philosophy in the Flesh: The Embodied Mind and Its Challenge to Western Thought&lt;/em&gt;, &lt;a href="https://openlibrary.org/works/OL1952995W/Philosophy_in_the_flesh" rel="noopener noreferrer"&gt;Basic Books, 1999&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;span id="ref-17"&gt;&lt;/span&gt;&lt;strong&gt;17.&lt;/strong&gt; Pearl, J., &lt;em&gt;Causality: Models, Reasoning, and Inference&lt;/em&gt;, &lt;a href="https://www.cambridge.org/core/books/causality/B0046844FAE10CBF274D4ACBDAEB5F5B" rel="noopener noreferrer"&gt;Cambridge University Press, 2009&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>lmm</category>
      <category>discuss</category>
    </item>
    <item>
      <title>🔐 OTP RS: RFC-Compliant OTP Input Components for WASM Frameworks</title>
      <dc:creator>Mahmoud 🦀</dc:creator>
      <pubDate>Sun, 04 Oct 2026 11:24:36 +0000</pubDate>
      <link>https://dev.to/wiseai/otp-rs-rfc-compliant-otp-input-components-for-wasm-frameworks-i45</link>
      <guid>https://dev.to/wiseai/otp-rs-rfc-compliant-otp-input-components-for-wasm-frameworks-i45</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Nǐ hǎo 👋!&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;You've seen the textbox. You've typed the number. You've waited three seconds for the SMS that never came, checked your spam folder, clicked "Resend", typed the number again, and finally admitted to yourself that 2FA is simultaneously the most important and most annoying invention of the modern web.&lt;/p&gt;

&lt;p&gt;Today, we make it marginally less annoying, at least on the Rust side. We're shipping &lt;a href="https://github.com/opensass/otprs" rel="noopener noreferrer"&gt;&lt;strong&gt;OTP RS&lt;/strong&gt;&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fns3sf2lxrmgui3d74xyz.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fns3sf2lxrmgui3d74xyz.gif" alt="Ferris Do be vibin" width="80" height="80"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What Even Is OTP RS?
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;OTP RS&lt;/strong&gt; is a composable, accessible, animated One-Time Password input component for &lt;strong&gt;Yew&lt;/strong&gt;, &lt;strong&gt;Dioxus&lt;/strong&gt;, and &lt;strong&gt;Leptos&lt;/strong&gt;. It implements the full verifier flow: slot-by-slot input, keyboard navigation, active/filled/invalid/disabled states, animated caret blink, digit-entry pop animation, and &lt;a href="https://rfc-editor.org/info/rfc4226" rel="noopener noreferrer"&gt;RFC 4226 (HOTP)&lt;/a&gt; + &lt;a href="https://www.rfc-editor.org/info/rfc6238" rel="noopener noreferrer"&gt;RFC 6238 (TOTP)&lt;/a&gt; validation, all in Rust, all in WASM, all without touching a single line of JavaScript.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flu7g9tcbso2f22jgqfty.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flu7g9tcbso2f22jgqfty.jpeg" alt="one does not simply implement OTP" width="651" height="384"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;If you've ever tried to build a 6-box OTP input from scratch, you know the drill. It starts with "just six inputs". Two hours later you're debugging focus management, backspace propagation, keyboard event edge cases, browser autofill hijacking your state, and the invisible iOS number pad refusing to appear. That's the origin story of OTP RS.&lt;/p&gt;

&lt;h2&gt;
  
  
  Component Architecture
&lt;/h2&gt;

&lt;p&gt;OTP RS follows the same composable anatomy as every other component in the Open SASS Kit. You compose what you need:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;Otp&lt;/code&gt;&lt;/strong&gt;: Root container. Owns the internal value state, focus coordination, and the RFC validation callbacks.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;Group&lt;/code&gt;&lt;/strong&gt;: A visual cluster of slots (e.g., three digits, then a separator, then three more).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;Slot&lt;/code&gt;&lt;/strong&gt;: Individual slot. Renders a visible character display on top of an invisible overlay &lt;code&gt;&amp;lt;input&amp;gt;&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;Separator&lt;/code&gt;&lt;/strong&gt;: The little dash in between groups.
&lt;/li&gt;
&lt;/ul&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;otprs&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;yew&lt;/span&gt;&lt;span class="p"&gt;::{&lt;/span&gt;&lt;span class="n"&gt;Otp&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Group&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Separator&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Slot&lt;/span&gt;&lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;yew&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;prelude&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="nd"&gt;#[function_component(VerificationInput)]&lt;/span&gt;
&lt;span class="k"&gt;pub&lt;/span&gt; &lt;span class="k"&gt;fn&lt;/span&gt; &lt;span class="nf"&gt;verification_input&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="k"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;Html&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nd"&gt;html!&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Otp&lt;/span&gt; &lt;span class="n"&gt;max_length&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="mi"&gt;6&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Enter your OTP"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Group&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
                &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Slot&lt;/span&gt; &lt;span class="n"&gt;index&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
                &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Slot&lt;/span&gt; &lt;span class="n"&gt;index&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
                &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Slot&lt;/span&gt; &lt;span class="n"&gt;index&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Group&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Separator&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Group&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
                &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Slot&lt;/span&gt; &lt;span class="n"&gt;index&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
                &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Slot&lt;/span&gt; &lt;span class="n"&gt;index&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
                &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Slot&lt;/span&gt; &lt;span class="n"&gt;index&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Group&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Otp&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;That's it. Focus management, digit propagation, state aggregation, and ARIA attributes are all handled. You just compose slots.&lt;/p&gt;
&lt;h2&gt;
  
  
  The Invisible Input Trick
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsc52a6iybhcjqxplzogv.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsc52a6iybhcjqxplzogv.jpeg" alt="What if I told you ma boy" width="643" height="389"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Here's the most important design decision in all of OTP RS: &lt;strong&gt;the &lt;code&gt;&amp;lt;input&amp;gt;&lt;/code&gt; element that receives keyboard events is completely invisible.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Each &lt;code&gt;Slot&lt;/code&gt; renders two layers:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;An invisible &lt;code&gt;&amp;lt;input&amp;gt;&lt;/code&gt; (via &lt;code&gt;input-rs&lt;/code&gt; with &lt;code&gt;otp_mode=true&lt;/code&gt;) that is &lt;code&gt;position: absolute; inset: 0; opacity: 0&lt;/code&gt;. It captures all keyboard focus and input events.&lt;/li&gt;
&lt;li&gt;A visible &lt;code&gt;&amp;lt;span&amp;gt;&lt;/code&gt; that displays the digit character and the blinking caret.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;This separates the &lt;strong&gt;input mechanics&lt;/strong&gt; from the &lt;strong&gt;visual presentation&lt;/strong&gt;, giving us full control over the slot's look without fighting browser defaults for &lt;code&gt;&amp;lt;input&amp;gt;&lt;/code&gt; styling.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;┌─────────────────────┐
│  Slot wrapper       │  ← position: relative; border; background; animation
│  ┌───────────────┐  │
│  │ &amp;lt;input&amp;gt;       │  │  ← absolute; opacity:0; captures keyboard events
│  └───────────────┘  │
│  &amp;lt;span&amp;gt;3&amp;lt;/span&amp;gt;     │  ← visible character display
│  &amp;lt;span class=caret/&amp;gt;│  ← blinking caret (when active &amp;amp; empty)
└─────────────────────┘
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;h2&gt;
  
  
  The Invisible Input That Wasn't Actually Invisible
&lt;/h2&gt;

&lt;p&gt;Here's a fun bug that bit us early on, hard.&lt;/p&gt;

&lt;p&gt;The slot design described above only works if the CSS for the invisible input is applied as an &lt;strong&gt;inline &lt;code&gt;style&lt;/code&gt; attribute&lt;/strong&gt;, not as a CSS &lt;code&gt;class&lt;/code&gt; attribute. The component originally passed the overlay CSS string to &lt;code&gt;input_class&lt;/code&gt;, a prop that sets the HTML &lt;code&gt;class=""&lt;/code&gt; attribute.&lt;/p&gt;

&lt;p&gt;Browsers don't style elements based on CSS property strings stuck in the class attribute. They look up class names in stylesheets. So what we got instead of an invisible overlay was a white rectangle aggressively covering the entire OTP component, like a censored emoji on live TV.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fz92y6bfd9cchnv5tep4w.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fz92y6bfd9cchnv5tep4w.jpeg" alt="that's not how this works meme" width="620" height="465"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The fix was to add an &lt;code&gt;input_style: &amp;amp;'static str&lt;/code&gt; prop to &lt;code&gt;input-rs&lt;/code&gt; in all three framework implementations, and apply it as &lt;code&gt;style="{props.input_style}"&lt;/code&gt; on the bare otp_mode &lt;code&gt;&amp;lt;input&amp;gt;&lt;/code&gt;. One line per framework. Six characters (&lt;code&gt;_style&lt;/code&gt; vs &lt;code&gt;_class&lt;/code&gt;). Three frameworks. Three PRs worth of suffering.&lt;/p&gt;
&lt;h2&gt;
  
  
  The Compiler Is Your Enemy (And Also Your Best Friend)
&lt;/h2&gt;

&lt;p&gt;Let us count the ways Rust fought us this time.&lt;/p&gt;
&lt;h3&gt;
  
  
  Episode 1: Hook in a Macro
&lt;/h3&gt;


&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="n"&gt;error&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;E0277&lt;/span&gt;&lt;span class="p"&gt;]:&lt;/span&gt; &lt;span class="n"&gt;the&lt;/span&gt; &lt;span class="k"&gt;trait&lt;/span&gt; &lt;span class="n"&gt;bound&lt;/span&gt; &lt;span class="err"&gt;`&lt;/span&gt;&lt;span class="k"&gt;impl&lt;/span&gt; &lt;span class="n"&gt;Hook&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Output&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="o"&gt;...&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;IntoPropValue&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;...&amp;gt;&lt;/span&gt;&lt;span class="err"&gt;`&lt;/span&gt; &lt;span class="n"&gt;is&lt;/span&gt; &lt;span class="n"&gt;not&lt;/span&gt; &lt;span class="n"&gt;satisfied&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;We tried calling &lt;code&gt;use_state(...)&lt;/code&gt; inside an &lt;code&gt;html!&lt;/code&gt; macro attribute. Yew forbids calling hooks anywhere except directly inside function component bodies. The macro expands to a closure, and hook calls need to be at the top level. Extracting &lt;code&gt;use_state&lt;/code&gt; calls to &lt;code&gt;let&lt;/code&gt; bindings before &lt;code&gt;html!&lt;/code&gt; fixed it.&lt;/p&gt;
&lt;h3&gt;
  
  
  Episode 2: &lt;code&gt;Box::leak&lt;/code&gt; and the &lt;code&gt;&amp;amp;'static str&lt;/code&gt; Obligation
&lt;/h3&gt;

&lt;p&gt;Dioxus and Leptos's &lt;code&gt;input-rs&lt;/code&gt; props require &lt;code&gt;&amp;amp;'static str&lt;/code&gt;. But our slot-specific strings like &lt;code&gt;"Digit 3"&lt;/code&gt; are computed at runtime. The only way to produce a &lt;code&gt;&amp;amp;'static str&lt;/code&gt; from a runtime &lt;code&gt;String&lt;/code&gt; without pulling in a string interner is to &lt;code&gt;Box::leak&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;label&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="k"&gt;'static&lt;/span&gt; &lt;span class="nb"&gt;str&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nn"&gt;Box&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;leak&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="nd"&gt;format!&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"Digit {}"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;index&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="nf"&gt;.into_boxed_str&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="p"&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Yes, this leaks memory on every slot render. Each &lt;code&gt;Slot&lt;/code&gt; render leaks ~15 bytes. Is this ideal? No. Does it compile? Yes. Is it the correct long-term solution? The correct long-term solution is a &lt;code&gt;Signal&amp;lt;String&amp;gt;&lt;/code&gt; prop type in input-rs, which is a future PR. For now: &lt;code&gt;Box::leak&lt;/code&gt; and move on.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgumh6q6hvpzuttgh8yn4.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgumh6q6hvpzuttgh8yn4.jpeg" alt="this is fine" width="717" height="349"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;h3&gt;
  
  
  Episode 3: The &lt;code&gt;as&lt;/code&gt; Cast That Broke Leptos
&lt;/h3&gt;

&lt;p&gt;The Leptos &lt;code&gt;view!&lt;/code&gt; macro cannot parse Rust cast expressions inline:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// This fails to parse inside view!:&lt;/span&gt;
&lt;span class="n"&gt;validate_function&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;(|&lt;/span&gt;&lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;String&lt;/span&gt;&lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="k"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;bool&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;true&lt;/span&gt; &lt;span class="p"&gt;})&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="k"&gt;fn&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;String&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;bool&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;The macro sees the &lt;code&gt;as&lt;/code&gt; keyword and gets confused about what's a prop name vs. a type expression. The fix: extract to a &lt;code&gt;let&lt;/code&gt; binding &lt;strong&gt;before&lt;/strong&gt; the &lt;code&gt;view!&lt;/code&gt; call:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;always_valid&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="k"&gt;fn&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;String&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;bool&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt;&lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="k"&gt;true&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="c1"&gt;// then inside view!:&lt;/span&gt;
&lt;span class="n"&gt;validate_function&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;always_valid&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Three lines in, five compilation cycles later. We hope this saves you ten minutes.&lt;/p&gt;
&lt;h3&gt;
  
  
  Episode 4: &lt;code&gt;String&lt;/code&gt; vs &lt;code&gt;&amp;amp;str&lt;/code&gt; in Dioxus &lt;code&gt;rsx!&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;Dioxus's &lt;code&gt;rsx!&lt;/code&gt; macro is strict about attribute types. When &lt;code&gt;slot_class&lt;/code&gt; was a &lt;code&gt;String&lt;/code&gt;, the macro would refuse:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="n"&gt;expected&lt;/span&gt; &lt;span class="err"&gt;`&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="err"&gt;`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;found&lt;/span&gt; &lt;span class="err"&gt;`&lt;/span&gt;&lt;span class="nb"&gt;String&lt;/span&gt;&lt;span class="err"&gt;`&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;&lt;code&gt;format!("...", ...)&lt;/code&gt; produces a &lt;code&gt;String&lt;/code&gt;. Dioxus attributes want &lt;code&gt;&amp;amp;str&lt;/code&gt;. The same &lt;code&gt;Box::leak&lt;/code&gt; pattern solved this too:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;slot_class&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="k"&gt;'static&lt;/span&gt; &lt;span class="nb"&gt;str&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nn"&gt;Box&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;leak&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="nd"&gt;format!&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"{} {}"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;ctx&lt;/span&gt;&lt;span class="py"&gt;.variant&lt;/span&gt;&lt;span class="nf"&gt;.to_slot_class&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt; &lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="py"&gt;.class&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="nf"&gt;.into_boxed_str&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="p"&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;h3&gt;
  
  
  Episode 5: The Inter-Group Focus Traversal Collision
&lt;/h3&gt;

&lt;p&gt;Here is a fun brain teaser: what happens when you put &lt;em&gt;two&lt;/em&gt; OTP components on the exact same page, and you start typing in the second one?&lt;br&gt;
Well, since our slots were originally assigned hardcoded IDs like &lt;code&gt;otp-slot-0&lt;/code&gt;, &lt;code&gt;otp-slot-1&lt;/code&gt;, the moment you typed a character in the second instance, &lt;code&gt;document.getElementById("otp-slot-1")&lt;/code&gt; would aggressively hijack focus and yank your cursor all the way back up to the &lt;em&gt;first&lt;/em&gt; OTP component on the page.&lt;/p&gt;

&lt;p&gt;The fix? Prefixing every slot ID with a unique &lt;code&gt;instance_id&lt;/code&gt; minted from a global atomic counter (&lt;code&gt;OTP_INSTANCE_COUNTER.fetch_add(1, Ordering::Relaxed)&lt;/code&gt;). Now every widget lives in its own perfectly scoped focus namespace, free from neighborhood turf wars.&lt;/p&gt;
&lt;h3&gt;
  
  
  Episode 6: The "Sticky" Backspace (vDOM vs Physical DOM)
&lt;/h3&gt;

&lt;p&gt;Across Leptos and Yew we noticed a bizarre issue: if you typed a character, erased it, and tried typing again, the &lt;code&gt;&amp;lt;input&amp;gt;&lt;/code&gt; would refuse to update. Or if you filled the very last slot, the input component became "sticky" and refused to overwrite the final character.&lt;/p&gt;

&lt;p&gt;The root cause was a classic Virtual DOM vs Physical DOM standoff. We were setting the internal state to &lt;code&gt;""&lt;/code&gt;, but frameworks optimize their renders. Leptos &lt;code&gt;input-rs&lt;/code&gt; used a one-way, read-once initialization for &lt;code&gt;value=handle.0.get()&lt;/code&gt;. Yew assumed the string was already empty and ignored the reconciliation. Because the physical HTML &lt;code&gt;&amp;lt;input&amp;gt;&lt;/code&gt; wasn't being forcefully synchronized, the raw DOM held onto the sticky character and choked out any new keystrokes.&lt;/p&gt;

&lt;p&gt;We had to bypass the frameworks entirely and manually flush the physical DOM element inside the keyboard event handlers using raw Web APIs (&lt;code&gt;input_ref.cast::&amp;lt;web_sys::HtmlInputElement&amp;gt;().unwrap().set_value("")&lt;/code&gt;). The lesson here? Sometimes the fastest way out of a reactive state desync is a direct, imperative smash to the physical DOM.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7amt7en2dkhidry7rkli.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7amt7en2dkhidry7rkli.jpeg" alt="it keeps happening" width="660" height="379"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  Keyboard Navigation
&lt;/h2&gt;

&lt;p&gt;One of the more satisfying pieces: full keyboard navigation across slots.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Any character key&lt;/strong&gt; → fills current slot, auto-advances focus to the next&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;Backspace&lt;/code&gt;&lt;/strong&gt; → clears current slot; if already empty, goes to the previous slot&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;ArrowLeft&lt;/code&gt;&lt;/strong&gt; → jumps to previous slot&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;ArrowRight&lt;/code&gt;&lt;/strong&gt; → jumps to next slot&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;Tab&lt;/code&gt;&lt;/strong&gt; → advances naturally (browser default, we don't intercept)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;All of this is handled in the &lt;code&gt;on_slot_keydown&lt;/code&gt; callback in the parent &lt;code&gt;Otp&lt;/code&gt; component, which uses &lt;code&gt;NodeRef&lt;/code&gt; (Yew) or the equivalent signal-based refs (Dioxus/Leptos) to imperatively &lt;code&gt;.focus()&lt;/code&gt; the target input.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s"&gt;"Backspace"&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;idx&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="c1"&gt;// slot is already empty, go back&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="nf"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;node&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;slot_refs&lt;/span&gt;&lt;span class="nf"&gt;.get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;idx&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="nf"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;input&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;node&lt;/span&gt;&lt;span class="py"&gt;.cast&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;HtmlInputElement&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;input&lt;/span&gt;&lt;span class="nf"&gt;.focus&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;No third-party focus-trap libraries. No jQuery. Pure DOM manipulation from Rust.&lt;/p&gt;
&lt;h2&gt;
  
  
  HOTP and TOTP Validation
&lt;/h2&gt;

&lt;p&gt;OTP RS ships RFC 4226 (HOTP) and RFC 6238 (TOTP) implementations using &lt;a href="https://crates.io/crates/totp-rs" rel="noopener noreferrer"&gt;&lt;code&gt;totp-rs&lt;/code&gt;&lt;/a&gt;. The SHA-1 HMAC is hand-rolled using the standard iterative block compression algorithm:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;pub&lt;/span&gt; &lt;span class="k"&gt;fn&lt;/span&gt; &lt;span class="nf"&gt;validate_hotp&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;secret&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nb"&gt;u8&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt;
    &lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;u64&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;code&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;digits&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;u32&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;Result&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt; &lt;span class="n"&gt;OtpValidationError&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;expected&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;hotp&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;secret&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;digits&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;expected&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;code&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nf"&gt;Ok&lt;/span&gt;&lt;span class="p"&gt;(())&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;else&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nf"&gt;Err&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nn"&gt;OtpValidationError&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;HotpMismatch&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;You can validate on complete:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;on_complete&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nn"&gt;Callback&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;from&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;move&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt;&lt;span class="n"&gt;code&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;String&lt;/span&gt;&lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;match&lt;/span&gt; &lt;span class="nf"&gt;validate_hotp&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;b"your-secret"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;code&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;6&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="nf"&gt;Ok&lt;/span&gt;&lt;span class="p"&gt;(())&lt;/span&gt; &lt;span class="k"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nn"&gt;web_sys&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;console&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;log_1&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="s"&gt;"Valid!"&lt;/span&gt;&lt;span class="nf"&gt;.into&lt;/span&gt;&lt;span class="p"&gt;()),&lt;/span&gt;
        &lt;span class="nf"&gt;Err&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nn"&gt;web_sys&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;console&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;warn_1&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="nd"&gt;format!&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"{e:?}"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="nf"&gt;.into&lt;/span&gt;&lt;span class="p"&gt;()),&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;The &lt;code&gt;hotp()&lt;/code&gt; function also lets you generate the expected code if you need to display a hint in development. For the HOTP example in the landing page, the valid code for secret &lt;code&gt;JBSWY3DPEHPK3PXP&lt;/code&gt; at counter 0 is computed at runtime via &lt;code&gt;hotp(b"JBSWY3DPEHPK3PXP", 0, 6)&lt;/code&gt;, no hardcoding required.&lt;/p&gt;
&lt;h2&gt;
  
  
  Quick Setup
&lt;/h2&gt;


&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Yew&lt;/span&gt;
cargo add otprs &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;yew

&lt;span class="c"&gt;# Dioxus&lt;/span&gt;
cargo add otprs &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;dio

&lt;span class="c"&gt;# Leptos&lt;/span&gt;
cargo add otprs &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;lep
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight toml"&gt;&lt;code&gt;&lt;span class="c"&gt;# Cargo.toml&lt;/span&gt;
&lt;span class="py"&gt;otprs&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="py"&gt;version&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="s"&gt;"0.1"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="py"&gt;features&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;"yew"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;The component ships its own CSS as inline styles computed from Rust. No separate stylesheet needed.&lt;/p&gt;
&lt;h2&gt;
  
  
  Final Thoughts
&lt;/h2&gt;

&lt;p&gt;Building OTP RS was a journey through the exact kind of subtle, cross-framework, cross-layer complexity that makes Rust Web development both rewarding and sometimes deeply frustrating. We fought the compiler more than once, discovered ways that browser defaults quietly break invisible design patterns, and shipped a &lt;code&gt;Box::leak&lt;/code&gt; we're not entirely proud of.&lt;/p&gt;

&lt;p&gt;But the result is solid: a composable, keyboard-navigable, RFC-compliant OTP input component that works identically across Yew, Dioxus, and Leptos, with zero JavaScript and enough ARIA to satisfy a WCAG auditor.&lt;/p&gt;

&lt;p&gt;The next time you're building a login flow in Rust WASM and you reach for a six-box code input, you don't have to write it from scratch anymore.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://otp-rs.netlify.app" rel="noopener noreferrer"&gt;&lt;br&gt;
&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fqcspj4eqdqxf6dp022kl.png" alt="Try It Out" width="215" height="66"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwl06pc60hq9ugm11p8vp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwl06pc60hq9ugm11p8vp.png" alt="Try It" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;


&lt;div class="ltag-github-readme-tag"&gt;
  &lt;div class="readme-overview"&gt;
    &lt;h2&gt;
      &lt;img src="https://assets.dev.to/assets/github-logo-5a155e1f9a670af7944dd5e12375bc76ed542ea80224905ecaf878b9157cdefc.svg" alt="GitHub logo"&gt;
      &lt;a href="https://github.com/opensass" rel="noopener noreferrer"&gt;
        opensass
      &lt;/a&gt; / &lt;a href="https://github.com/opensass/otprs" rel="noopener noreferrer"&gt;
        otprs
      &lt;/a&gt;
    &lt;/h2&gt;
    &lt;h3&gt;
      🔐 A highly customizable OTP component for WASM frameworks (Powered by Input RS).
    &lt;/h3&gt;
  &lt;/div&gt;
  &lt;div class="ltag-github-body"&gt;
    
&lt;div id="readme" class="md"&gt;&lt;div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h1 class="heading-element"&gt;🔐 OTP RS&lt;/h1&gt;
&lt;/div&gt;

&lt;p&gt;&lt;a href="https://crates.io/crates/otprs" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/99c979b578eac0caf385178102db5a682324271fa35878e410cbc97bf35c3b78/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f762f6f74707273" alt="Crates.io"&gt;&lt;/a&gt;
&lt;a href="https://crates.io/crates/otprs" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/605694ec18192e4e88b5a6d6d75324745591bf6e335f926f8dfd3435dcc511a3/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f642f6f74707273" alt="Crates.io Downloads"&gt;&lt;/a&gt;
&lt;a rel="noopener noreferrer nofollow" href="https://camo.githubusercontent.com/459a3bd96f34d40adfa48f7ea9f148fe03e5601b8e88cc12ec7b48149a0a5f40/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f6c2f6f74707273"&gt;&lt;img src="https://camo.githubusercontent.com/459a3bd96f34d40adfa48f7ea9f148fe03e5601b8e88cc12ec7b48149a0a5f40/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f6c2f6f74707273" alt="Crates.io License"&gt;&lt;/a&gt;
&lt;a href="https://www.rust-lang.org/" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/44b045d4da6c2fd8024c8c66a350a4c8bb9c17faf50009f34dbe64c530de2454/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d616465253230776974682d527573742d3166343235662e7376673f6c6f676f3d72757374266c6f676f436f6c6f723d7768697465" alt="made-with-rust"&gt;&lt;/a&gt;
&lt;a href="https://www.rust-lang.org" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a90d14c350ec66cb0b131f5826793f397b954ed4eeeaa002e4285d7ff7f1a54d/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f527573742d312e39302532422d626c75652e737667" alt="Rust"&gt;&lt;/a&gt;
&lt;a href="https://github.com/opensass" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/5ca62441414bacaa54c6c6e5b68e46c76305947b6bf498c4949fc71c1b4b10dd/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d61696e7461696e65642533462d7965732d677265656e2e737667" alt="Maintenance"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://discord.gg/b5JbvHW5nv" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/1de0ff4ce5ecb14813fe0a4ae22bfb7ab081d2255bde28b216e2d3dc454524d9/68747470733a2f2f646362616467652e6c696d65732e70696e6b2f6170692f7365727665722f62354a62764857356e76" alt="Open SASS Discord"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a rel="noopener noreferrer nofollow" href="https://raw.githubusercontent.com/opensass/otprs/refs/heads/main/assets/logo.png"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fraw.githubusercontent.com%2Fopensass%2Fotprs%2Frefs%2Fheads%2Fmain%2Fassets%2Flogo.png" alt="logo"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🎬 Demo&lt;/h2&gt;
&lt;/div&gt;
&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Framework&lt;/th&gt;
&lt;th&gt;Live Demo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Yew&lt;/td&gt;
&lt;td&gt;&lt;a href="https://otp-rs.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dioxus&lt;/td&gt;
&lt;td&gt;&lt;a href="https://otp-dio.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Leptos&lt;/td&gt;
&lt;td&gt;&lt;a href="https://otp-lep.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;📜 Intro&lt;/h2&gt;

&lt;/div&gt;
&lt;p&gt;A highly customizable, accessible OTP (One-Time Password) input component for WASM frameworks: Yew, Dioxus, and Leptos.&lt;/p&gt;
&lt;p&gt;Supports animated per-slot digit entry with automatic focus traversal, &lt;code&gt;primary&lt;/code&gt; and &lt;code&gt;secondary&lt;/code&gt; visual variants, built-in HOTP/TOTP validation per RFC 4226 and RFC 6238, and full WCAG compliance.&lt;/p&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🤔 Why OTP RS?&lt;/h2&gt;

&lt;/div&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;🎨 Fully Customizable&lt;/strong&gt;: Control every attribute, class, style, variant, pattern, ARIA labels and more, on the outermost container, each group, each slot, and each separator.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;⌨ Smart Focus Management&lt;/strong&gt;: Typing a digit automatically advances focus. Backspace regresses focus. Arrow keys navigate left and right.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;✨ Animated Entry&lt;/strong&gt;: Each digit pops with a scale animation when entered, and a blinking caret is shown in the active empty slot.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;🔐 Built-in Validation&lt;/strong&gt;: Validate against HOTP (RFC 4226) or TOTP (RFC 6238) using a pure-Rust implementation, no C, no…&lt;/li&gt;
&lt;/ol&gt;&lt;/div&gt;
  &lt;/div&gt;
  &lt;div class="gh-btn-container"&gt;&lt;a class="gh-btn" href="https://github.com/opensass/otprs" rel="noopener noreferrer"&gt;View on GitHub&lt;/a&gt;&lt;/div&gt;
&lt;/div&gt;


&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;We are Open SASS, babe!&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;We're working tirelessly on making Rust web development extremely easy for everyone.&lt;/p&gt;

&lt;p&gt;If you made it this far, it would be nice if you could &lt;a href="https://discord.gg/b5JbvHW5nv" rel="noopener noreferrer"&gt;join us on Discord&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Till next time 👋!&lt;/p&gt;
&lt;/blockquote&gt;

</description>
      <category>webdev</category>
      <category>rust</category>
      <category>css</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>📋 Form RS: Production-Ready Form Components for WASM Frameworks</title>
      <dc:creator>Mahmoud 🦀</dc:creator>
      <pubDate>Sun, 04 Oct 2026 11:24:25 +0000</pubDate>
      <link>https://dev.to/wiseai/form-rs-production-ready-form-components-for-wasm-frameworks-4c03</link>
      <guid>https://dev.to/wiseai/form-rs-production-ready-form-components-for-wasm-frameworks-4c03</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Salut 👋!&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If there's one thing that unites frontend developers across every language, framework, and decade of web history, it's a deep, personal, somewhat traumatic relationship with HTML forms.&lt;/p&gt;

&lt;p&gt;You know the drill. You write a &lt;code&gt;&amp;lt;form&amp;gt;&lt;/code&gt;. You add an &lt;code&gt;&amp;lt;input&amp;gt;&lt;/code&gt;. You add a &lt;code&gt;&amp;lt;label&amp;gt;&lt;/code&gt;. You write the JavaScript to validate it on &lt;code&gt;blur&lt;/code&gt;. You add a &lt;code&gt;&amp;lt;p&amp;gt;&lt;/code&gt; for the error message. You wire up &lt;code&gt;aria-describedby&lt;/code&gt; so screen readers can find the error. You set &lt;code&gt;aria-invalid&lt;/code&gt; on the input. You set &lt;code&gt;aria-required&lt;/code&gt;. You check &lt;code&gt;event.preventDefault()&lt;/code&gt;. You realize you've been writing a custom form library for the last four hours. You consider leaving the industry.&lt;/p&gt;

&lt;p&gt;That stops today. We're shipping &lt;a href="https://github.com/opensass/form-rs" rel="noopener noreferrer"&gt;&lt;strong&gt;Form RS&lt;/strong&gt;&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqczhcuyhpnfgc1757270.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqczhcuyhpnfgc1757270.gif" alt="chillin ferris" width="136" height="200"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What Is Form RS?
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Form RS&lt;/strong&gt; is a fully composable, WCAG 2.2 AA compliant, production-ready form component library for &lt;strong&gt;Yew&lt;/strong&gt;, &lt;strong&gt;Dioxus&lt;/strong&gt;, and &lt;strong&gt;Leptos&lt;/strong&gt;. It wraps &lt;a href="https://github.com/opensass/input-rs" rel="noopener noreferrer"&gt;&lt;strong&gt;Input RS&lt;/strong&gt;&lt;/a&gt; for the actual &lt;code&gt;&amp;lt;input&amp;gt;&lt;/code&gt; rendering, provides a complete context-driven architecture for validation state propagation, and ships seven discrete components that you can mix freely.&lt;/p&gt;

&lt;p&gt;Think of it as the form library you would build yourself if you had time, patience, and hadn't already burned both writing &lt;code&gt;&amp;lt;div class="form-group"&amp;gt;&lt;/code&gt; for the 8000th time.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Seven Components
&lt;/h2&gt;

&lt;p&gt;Form RS ships a composable hierarchy, not a monolith.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;code&gt;Form&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;The outermost container. Wraps &lt;code&gt;&amp;lt;form&amp;gt;&lt;/code&gt; with configurable &lt;code&gt;method&lt;/code&gt;, &lt;code&gt;action&lt;/code&gt;, &lt;code&gt;enctype&lt;/code&gt;, &lt;code&gt;autocomplete&lt;/code&gt;, ARIA labels, and submit/reset/invalid callbacks. There are two validation modes:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="nn"&gt;ValidationBehavior&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Native&lt;/span&gt;   &lt;span class="c1"&gt;// HTML5 + browser popups (default)&lt;/span&gt;
&lt;span class="nn"&gt;ValidationBehavior&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Aria&lt;/span&gt;     &lt;span class="c1"&gt;// Real-time ARIA errors, no popups, submit never blocked&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;h3&gt;
  
  
  &lt;code&gt;Control&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;The context provider. Wraps a single field, distributes &lt;code&gt;disabled&lt;/code&gt;, &lt;code&gt;error&lt;/code&gt;, &lt;code&gt;focused&lt;/code&gt;, &lt;code&gt;required&lt;/code&gt;, &lt;code&gt;variant&lt;/code&gt;, &lt;code&gt;color&lt;/code&gt;, and &lt;code&gt;size&lt;/code&gt; state to every child that reads &lt;code&gt;FormControlContext&lt;/code&gt;. Your labels and helper text automatically inherit this state without prop drilling.&lt;/p&gt;
&lt;h3&gt;
  
  
  &lt;code&gt;Label&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;Renders a &lt;code&gt;&amp;lt;label&amp;gt;&lt;/code&gt; that visually and semantically tracks the control's state. It goes red when there's an error. It glows when focused. It shows the required asterisk automatically. You don't have to think about any of this.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// In Yew:&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Label&lt;/span&gt; &lt;span class="n"&gt;html_for&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"email"&lt;/span&gt; &lt;span class="n"&gt;error&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="k"&gt;true&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;focused&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="k"&gt;false&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"Email address"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Label&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;h3&gt;
  
  
  &lt;code&gt;Helper&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;A &lt;code&gt;&amp;lt;p&amp;gt;&lt;/code&gt; element below the input. Changes color based on validation state:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Helper&lt;/span&gt; &lt;span class="n"&gt;error&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="k"&gt;true&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"Not a valid email."&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Helper&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Helper&lt;/span&gt; &lt;span class="n"&gt;valid&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="k"&gt;true&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"Looks great!"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Helper&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Three states, zero class strings.&lt;/p&gt;
&lt;h3&gt;
  
  
  &lt;code&gt;Group&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;Groups related checkboxes or radio buttons in a &lt;code&gt;&amp;lt;fieldset&amp;gt;&lt;/code&gt;-adjacent &lt;code&gt;&amp;lt;div&amp;gt;&lt;/code&gt;. The &lt;code&gt;row&lt;/code&gt; prop flips the layout from column to horizontal. The &lt;code&gt;aria_label&lt;/code&gt; wires up a &lt;code&gt;role="group"&lt;/code&gt; for screen readers.&lt;/p&gt;
&lt;h3&gt;
  
  
  &lt;code&gt;ControlLabel&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;Wraps a form control (checkbox, radio, switch) with its associated label text. Controls label placement (&lt;code&gt;End&lt;/code&gt;, &lt;code&gt;Start&lt;/code&gt;, &lt;code&gt;Top&lt;/code&gt;, &lt;code&gt;Bottom&lt;/code&gt;), required asterisks, and disabled styling.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;ControlLabel&lt;/span&gt;
    &lt;span class="n"&gt;control&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nd"&gt;html!&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;input&lt;/span&gt; &lt;span class="k"&gt;type&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"checkbox"&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;}}&lt;/span&gt;
    &lt;span class="n"&gt;label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nd"&gt;html!&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;span&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"Email notifications"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;span&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;}}&lt;/span&gt;
    &lt;span class="n"&gt;label_placement&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;LabelPlacement&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;End&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;h3&gt;
  
  
  &lt;code&gt;Field&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;This is the one you'll use most. A drop-in composition of &lt;code&gt;Control + Label + Input + Helper&lt;/code&gt; with reactive focus rings, error/valid ring states, ARIA attributes, and helper text management.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Field&lt;/span&gt;
    &lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"email"&lt;/span&gt;
    &lt;span class="n"&gt;label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Email address"&lt;/span&gt;
    &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="err"&gt;#&lt;/span&gt;&lt;span class="k"&gt;type&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"email"&lt;/span&gt;
    &lt;span class="n"&gt;placeholder&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"ferris@opensass.org"&lt;/span&gt;
    &lt;span class="n"&gt;helper_text&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Enter a valid email."&lt;/span&gt;
    &lt;span class="n"&gt;required&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="k"&gt;true&lt;/span&gt;
    &lt;span class="n"&gt;full_width&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="k"&gt;true&lt;/span&gt;
    &lt;span class="n"&gt;handle&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;email&lt;/span&gt;&lt;span class="nf"&gt;.clone&lt;/span&gt;&lt;span class="p"&gt;()}&lt;/span&gt;
    &lt;span class="n"&gt;valid_handle&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;email_valid&lt;/span&gt;&lt;span class="nf"&gt;.clone&lt;/span&gt;&lt;span class="p"&gt;()}&lt;/span&gt;
    &lt;span class="n"&gt;validate_function&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Callback&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;from&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;validate_email&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;
&lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;One component. Fully wired. WCAG compliant. You're done.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fiiezjh4vh6gcpbgmns6h.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fiiezjh4vh6gcpbgmns6h.png" alt="it just works" width="683" height="366"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  Validation Architecture
&lt;/h2&gt;

&lt;p&gt;Form RS supports two distinct validation paradigms:&lt;/p&gt;
&lt;h3&gt;
  
  
  Native HTML5 Validation
&lt;/h3&gt;

&lt;p&gt;Uses browser-native &lt;code&gt;required&lt;/code&gt;, &lt;code&gt;pattern&lt;/code&gt;, &lt;code&gt;minlength&lt;/code&gt;, &lt;code&gt;maxlength&lt;/code&gt;, and &lt;code&gt;type="email"&lt;/code&gt; constraints. The browser handles error messages. Form submission is blocked on invalid fields. This is the &lt;code&gt;ValidationBehavior::Native&lt;/code&gt; default.&lt;/p&gt;
&lt;h3&gt;
  
  
  External/ARIA Validation
&lt;/h3&gt;

&lt;p&gt;Pass a &lt;code&gt;ValidationState&lt;/code&gt; explicitly, from a server response, a complex cross-field rule, or your own logic:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="nn"&gt;ValidationState&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nb"&gt;None&lt;/span&gt;        &lt;span class="c1"&gt;// No judgment, untouched&lt;/span&gt;
&lt;span class="nn"&gt;ValidationState&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Valid&lt;/span&gt;       &lt;span class="c1"&gt;// Green ring, success helper text&lt;/span&gt;
&lt;span class="nn"&gt;ValidationState&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;Invalid&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;msg&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="c1"&gt;// Red ring, error helper text, aria-invalid="true"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Server errors? Set &lt;code&gt;validation_state={ValidationState::Invalid("Email already in use.".into())}&lt;/code&gt; on the field. The error surfaces immediately. The ARIA is correct. Done.&lt;/p&gt;
&lt;h2&gt;
  
  
  Accessibility Built In
&lt;/h2&gt;

&lt;p&gt;This isn't "we added aria-label" accessibility. This is the real thing.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Every &lt;code&gt;Field&lt;/code&gt; generates a unique &lt;code&gt;{id}-helper&lt;/code&gt; element ID and passes it as &lt;code&gt;aria-describedby&lt;/code&gt; on the underlying &lt;code&gt;&amp;lt;input&amp;gt;&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;aria-required&lt;/code&gt; and &lt;code&gt;aria-invalid&lt;/code&gt; are set precisely based on prop + validation state, not just "always true".&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;Helper&lt;/code&gt; renders with &lt;code&gt;role="alert"&lt;/code&gt; when in error state, so screen reader users hear errors without tabbing to them.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;Label&lt;/code&gt; is always linked to its input via &lt;code&gt;for&lt;/code&gt;/&lt;code&gt;html_for&lt;/code&gt;. No floating labels that break semantics.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;Group&lt;/code&gt; propagates &lt;code&gt;role="group"&lt;/code&gt; with &lt;code&gt;aria-label&lt;/code&gt; for checkbox/radio clusters.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Audit-passing HTML forms. In Rust. Across three WASM frameworks.&lt;/p&gt;
&lt;h2&gt;
  
  
  The &lt;code&gt;ValidationState&lt;/code&gt; Pattern
&lt;/h2&gt;

&lt;p&gt;This is the piece that makes server-side validation ergonomic:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;pub&lt;/span&gt; &lt;span class="k"&gt;enum&lt;/span&gt; &lt;span class="n"&gt;ValidationState&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nb"&gt;None&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;Valid&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nf"&gt;Invalid&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;String&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Pass &lt;code&gt;None&lt;/code&gt; on a fresh field. Pass &lt;code&gt;Valid&lt;/code&gt; once you've confirmed on the backend. Pass &lt;code&gt;Invalid&lt;/code&gt; with your error message string when the server rejects it. The component does the rest.&lt;/p&gt;
&lt;h2&gt;
  
  
  Variant, Color, and Size System
&lt;/h2&gt;

&lt;p&gt;Form RS exposes a full semantic token system for the input appearance:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Visual input style&lt;/span&gt;
&lt;span class="nn"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Outlined&lt;/span&gt;  &lt;span class="c1"&gt;// Default, bordered input box&lt;/span&gt;
&lt;span class="nn"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Filled&lt;/span&gt;    &lt;span class="c1"&gt;// Solid filled background&lt;/span&gt;
&lt;span class="nn"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Standard&lt;/span&gt;  &lt;span class="c1"&gt;// Bottom-border only&lt;/span&gt;

&lt;span class="c1"&gt;// Accent color (rings, labels, helper text)&lt;/span&gt;
&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Primary&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Secondary&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Error&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Info&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Success&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Warning&lt;/span&gt;

&lt;span class="c1"&gt;// Input density&lt;/span&gt;
&lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Small&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Medium&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Building a dense admin data-entry form? &lt;code&gt;Size::Small&lt;/code&gt;. Consumer onboarding flow? &lt;code&gt;Size::Medium&lt;/code&gt;. Dark theme with error highlights? &lt;code&gt;Color::Error&lt;/code&gt;. The system handles the visual output; you just name the intent.&lt;/p&gt;
&lt;h2&gt;
  
  
  Quick Setup
&lt;/h2&gt;

&lt;p&gt;Stop writing raw HTML form boilerplate. Do this:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Yew&lt;/span&gt;
cargo add form-rs &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;yew

&lt;span class="c"&gt;# Dioxus&lt;/span&gt;
cargo add form-rs &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;dio

&lt;span class="c"&gt;# Leptos&lt;/span&gt;
cargo add form-rs &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;lep
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;h2&gt;
  
  
  Final Thoughts
&lt;/h2&gt;

&lt;p&gt;Forms are foundational. Every user interaction that matters, login, registration, checkout, profile editing, contact, search, flows through a form. Getting them right means getting ARIA right, validation right, focus state right, and error surfacing right. Every time. On every field.&lt;/p&gt;

&lt;p&gt;Form RS is the answer to "who has time for all of that." We did. You don't have to.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://form-rs.netlify.app" rel="noopener noreferrer"&gt;&lt;br&gt;
&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fqcspj4eqdqxf6dp022kl.png" alt="Try It Out" width="215" height="66"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwl06pc60hq9ugm11p8vp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwl06pc60hq9ugm11p8vp.png" alt="Try It" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;


&lt;div class="ltag-github-readme-tag"&gt;
  &lt;div class="readme-overview"&gt;
    &lt;h2&gt;
      &lt;img src="https://assets.dev.to/assets/github-logo-5a155e1f9a670af7944dd5e12375bc76ed542ea80224905ecaf878b9157cdefc.svg" alt="GitHub logo"&gt;
      &lt;a href="https://github.com/opensass" rel="noopener noreferrer"&gt;
        opensass
      &lt;/a&gt; / &lt;a href="https://github.com/opensass/form-rs" rel="noopener noreferrer"&gt;
        form-rs
      &lt;/a&gt;
    &lt;/h2&gt;
    &lt;h3&gt;
      📋 A highly customizable Form component for WASM frameworks (Powered by Input RS).
    &lt;/h3&gt;
  &lt;/div&gt;
  &lt;div class="ltag-github-body"&gt;
    
&lt;div id="readme" class="md"&gt;&lt;div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h1 class="heading-element"&gt;📋 Form RS&lt;/h1&gt;
&lt;/div&gt;

&lt;p&gt;&lt;a href="https://crates.io/crates/form-rs" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/914def72e9822842f27ce04ffbe02abeb937ac8a292eebca685b30adcd902eed/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f762f666f726d2d7273" alt="Crates.io"&gt;&lt;/a&gt;
&lt;a href="https://crates.io/crates/form-rs" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/baea95c455274af1eb77ab50feaa5a0ca76934a046ecdbcaa0387a463856b143/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f642f666f726d2d7273" alt="Crates.io Downloads"&gt;&lt;/a&gt;
&lt;a rel="noopener noreferrer nofollow" href="https://camo.githubusercontent.com/24654307ae01cacd5f0ed9b82e587918acb5fc25eb5cdf7e36961991633598b1/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f6c2f666f726d2d7273"&gt;&lt;img src="https://camo.githubusercontent.com/24654307ae01cacd5f0ed9b82e587918acb5fc25eb5cdf7e36961991633598b1/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f6c2f666f726d2d7273" alt="Crates.io License"&gt;&lt;/a&gt;
&lt;a href="https://www.rust-lang.org/" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/44b045d4da6c2fd8024c8c66a350a4c8bb9c17faf50009f34dbe64c530de2454/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d616465253230776974682d527573742d3166343235662e7376673f6c6f676f3d72757374266c6f676f436f6c6f723d7768697465" alt="made-with-rust"&gt;&lt;/a&gt;
&lt;a href="https://www.rust-lang.org" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/31c82dd347f4da3b0ee4fb00bdbab1450d962c202a7f1d46feeb52cb06c634fb/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f527573742d312e38392532422d626c75652e737667" alt="Rust"&gt;&lt;/a&gt;
&lt;a href="https://github.com/opensass" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/5ca62441414bacaa54c6c6e5b68e46c76305947b6bf498c4949fc71c1b4b10dd/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d61696e7461696e65642533462d7965732d677265656e2e737667" alt="Maintenance"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://discord.gg/b5JbvHW5nv" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/1de0ff4ce5ecb14813fe0a4ae22bfb7ab081d2255bde28b216e2d3dc454524d9/68747470733a2f2f646362616467652e6c696d65732e70696e6b2f6170692f7365727665722f62354a62764857356e76" alt="Open SASS Discord"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a rel="noopener noreferrer nofollow" href="https://raw.githubusercontent.com/opensass/form-rs/refs/heads/main/assets/logo.png"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fraw.githubusercontent.com%2Fopensass%2Fform-rs%2Frefs%2Fheads%2Fmain%2Fassets%2Flogo.png" alt="logo"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🎬 Demo&lt;/h2&gt;
&lt;/div&gt;
&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Framework&lt;/th&gt;
&lt;th&gt;Live Demo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Yew&lt;/td&gt;
&lt;td&gt;&lt;a href="https://form-rs.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dioxus&lt;/td&gt;
&lt;td&gt;&lt;a href="https://form-dio.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Leptos&lt;/td&gt;
&lt;td&gt;&lt;a href="https://form-lep.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;📜 Intro&lt;/h2&gt;

&lt;/div&gt;
&lt;p&gt;A highly customizable, accessible form component library for WASM frameworks: Yew, Dioxus, and Leptos.
Supports HTML5 and ARIA validation, composable sub-components (&lt;code&gt;Form&lt;/code&gt;, &lt;code&gt;Control&lt;/code&gt;, &lt;code&gt;FormLabel&lt;/code&gt;,
&lt;code&gt;Helper&lt;/code&gt;, &lt;code&gt;Group&lt;/code&gt;, &lt;code&gt;ControlLabel&lt;/code&gt;, &lt;code&gt;Field&lt;/code&gt;), and full WCAG 2.2 AA compliance.&lt;/p&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🤔 Why Form RS?&lt;/h2&gt;

&lt;/div&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;🎨 Fully Customizable&lt;/strong&gt;: Control variant, color, size, class, style, ARIA labels, and every sub-component attribute.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;🧩 Composable API&lt;/strong&gt;: Mix &lt;code&gt;Form&lt;/code&gt;, &lt;code&gt;Control&lt;/code&gt;, &lt;code&gt;FormLabel&lt;/code&gt;, &lt;code&gt;Helper&lt;/code&gt;, &lt;code&gt;Group&lt;/code&gt;, &lt;code&gt;ControlLabel&lt;/code&gt;, and &lt;code&gt;Field&lt;/code&gt; independently or together.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;✅ Dual Validation&lt;/strong&gt;: Supports native HTML5 validation and real-time ARIA error messaging.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;♿ Accessible by Default&lt;/strong&gt;: &lt;code&gt;aria-describedby&lt;/code&gt;, &lt;code&gt;aria-required&lt;/code&gt;, &lt;code&gt;aria-invalid&lt;/code&gt;, and &lt;code&gt;role="alert"&lt;/code&gt; wired up automatically.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;🔧 Framework Agnostic&lt;/strong&gt;: Same API semantics across Yew, Dioxus, and Leptos.&lt;/li&gt;
&lt;/ol&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;Y Yew Usage&lt;/h2&gt;

&lt;/div&gt;

&lt;p&gt;Refer to &lt;a href="https://github.com/opensass/form-rs/blob/main/YEW.md" rel="noopener noreferrer"&gt;our guide&lt;/a&gt; to integrate this component into…&lt;/p&gt;&lt;/div&gt;
  &lt;/div&gt;
  &lt;div class="gh-btn-container"&gt;&lt;a class="gh-btn" href="https://github.com/opensass/form-rs" rel="noopener noreferrer"&gt;View on GitHub&lt;/a&gt;&lt;/div&gt;
&lt;/div&gt;


&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;We are Open SASS, babe!&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;We're working tirelessly on making Rust web development extremely easy for everyone.&lt;/p&gt;

&lt;p&gt;If you made it this far, it would be nice if you could &lt;a href="https://discord.gg/b5JbvHW5nv" rel="noopener noreferrer"&gt;join us on Discord&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Till next time 👋!&lt;/p&gt;
&lt;/blockquote&gt;

</description>
      <category>webdev</category>
      <category>rust</category>
      <category>css</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>🖥️ Code RS: CDN-Free Syntax-Highlighted Code Components for WASM</title>
      <dc:creator>Mahmoud 🦀</dc:creator>
      <pubDate>Sun, 04 Oct 2026 11:24:17 +0000</pubDate>
      <link>https://dev.to/wiseai/code-rs-cdn-free-syntax-highlighted-code-components-for-wasm-njc</link>
      <guid>https://dev.to/wiseai/code-rs-cdn-free-syntax-highlighted-code-components-for-wasm-njc</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Privyet 👋!&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;You know that moment when you paste a &lt;code&gt;&amp;lt;pre&amp;gt;&amp;lt;code&amp;gt;&lt;/code&gt; block into your app and it looks like it was styled in 2003 by someone who had just discovered &lt;code&gt;color: green&lt;/code&gt;? No theme. No copy button. No language badge. Just raw, uncolored text sitting in a box that someone called "good enough"?&lt;/p&gt;

&lt;p&gt;Yeah. We fixed that. Today we're shipping &lt;a href="https://github.com/opensass/coders" rel="noopener noreferrer"&gt;&lt;strong&gt;Code RS&lt;/strong&gt;&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5p3yzfxcd12l7l45st9y.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5p3yzfxcd12l7l45st9y.jpeg" alt="One does not simply"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What Is Code RS?
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Code RS&lt;/strong&gt; is a production-ready, fully-themed, accessible code display component for &lt;strong&gt;Yew&lt;/strong&gt;, &lt;strong&gt;Dioxus&lt;/strong&gt;, and &lt;strong&gt;Leptos&lt;/strong&gt;. It does everything the ecosystem was missing:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Inline &lt;code&gt;&amp;lt;Code&amp;gt;&lt;/code&gt;&lt;/strong&gt;: colored, sized, variant-aware, with ARIA semantics.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;code&gt;&amp;lt;Block&amp;gt;&lt;/code&gt;&lt;/strong&gt;: a composable container with header, title, language badge, copy trigger, and scrollable content area.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pure-Rust syntax highlighting&lt;/strong&gt;: zero CDN, zero JavaScript, compiles to clean WASM, 20+ languages.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;8 built-in themes&lt;/strong&gt;: OneDark, Dracula, NightOwl, GitHub Dark/Light, Solarized, Monokai, Nord, all switchable via a single &lt;code&gt;theme&lt;/code&gt; prop.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;No Prism.js. No highlight.js. No 10MB script tag loaded from a CDN you definitely trust completely. Just Rust, bytes, and inline &lt;code&gt;style=&lt;/code&gt; spans.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Big Idea
&lt;/h2&gt;

&lt;p&gt;Here's the thing about syntax highlighting in WASM apps: every existing solution assumes JavaScript. Prism.js needs a DOM. highlight.js needs a runtime. Shiki needs Node. Tree-sitter is great, but it weighs as much as a sedan.&lt;/p&gt;

&lt;p&gt;So we wrote our own.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmanuf7qi630dqih250ak.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmanuf7qi630dqih250ak.jpeg" alt="Pure-Rust tokenizer, no biggie"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;highlight_code(code, lang, theme)&lt;/code&gt; function in &lt;code&gt;common.rs&lt;/code&gt; is a hand-rolled, char-by-char tokenizer that handles:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Block comments (&lt;code&gt;/* */&lt;/code&gt;), single-line comments (&lt;code&gt;//&lt;/code&gt;, &lt;code&gt;#&lt;/code&gt;, &lt;code&gt;--&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;Double/single-quoted strings and JS template literals&lt;/li&gt;
&lt;li&gt;Hex and float number literals with suffixes (&lt;code&gt;0xFF&lt;/code&gt;, &lt;code&gt;1.0f32&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;Rust macros (&lt;code&gt;println!&lt;/code&gt;, &lt;code&gt;vec!&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;Python/CSS decorators (&lt;code&gt;@dataclass&lt;/code&gt;, &lt;code&gt;@media&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;HTML tag names (&lt;code&gt;&amp;lt;div&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;/span&amp;gt;&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;PascalCase → type, ALL_CAPS → constant, &lt;code&gt;ident(&lt;/code&gt; → function call&lt;/li&gt;
&lt;li&gt;Language-specific keyword sets (Rust, Python, TypeScript, SQL, Bash, 16 more)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;All token spans get &lt;strong&gt;inline &lt;code&gt;style=&lt;/code&gt; attributes&lt;/strong&gt; from the chosen theme. No CSS classes. No external stylesheet. Just &lt;code&gt;&amp;lt;span style="color:#c678dd;font-weight:600"&amp;gt;fn&amp;lt;/span&amp;gt;&lt;/code&gt;, and it works everywhere, including iframes and shadow DOM.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;coders&lt;/span&gt;&lt;span class="p"&gt;::{&lt;/span&gt;&lt;span class="n"&gt;Language&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Theme&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;highlight_code&lt;/span&gt;&lt;span class="p"&gt;};&lt;/span&gt;

&lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;html&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;highlight_code&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="s"&gt;"fn main() {&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s"&gt;    println!(&lt;/span&gt;&lt;span class="se"&gt;\"&lt;/span&gt;&lt;span class="s"&gt;Hello!&lt;/span&gt;&lt;span class="se"&gt;\"&lt;/span&gt;&lt;span class="s"&gt;);&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s"&gt;}"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nn"&gt;Language&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Rust&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="nn"&gt;Theme&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Dracula&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="c1"&gt;// → "&amp;lt;span style="color:#ff79c6;font-weight:600"&amp;gt;fn&amp;lt;/span&amp;gt; ..."&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;h2&gt;
  
  
  Components
&lt;/h2&gt;
&lt;h3&gt;
  
  
  &lt;code&gt;Code&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;The simplest unit. A &lt;code&gt;&amp;lt;code&amp;gt;&lt;/code&gt; element with color, variant, and size props.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Yew&lt;/span&gt;
&lt;span class="nd"&gt;html!&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Code&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Accent&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;variant&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Subtle&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;size&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Sm&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
        &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"console.log(&lt;/span&gt;&lt;span class="se"&gt;\"&lt;/span&gt;&lt;span class="s"&gt;Hello, world!&lt;/span&gt;&lt;span class="se"&gt;\"&lt;/span&gt;&lt;span class="s"&gt;)"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Code&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Variants work exactly as you'd expect from the rest of Open SASS Kit: &lt;code&gt;Solid&lt;/code&gt;, &lt;code&gt;Subtle&lt;/code&gt;, &lt;code&gt;Outline&lt;/code&gt;, &lt;code&gt;Surface&lt;/code&gt;, &lt;code&gt;Plain&lt;/code&gt;. Colors are the full palette: &lt;code&gt;Default&lt;/code&gt;, &lt;code&gt;Red&lt;/code&gt;, &lt;code&gt;Orange&lt;/code&gt;, &lt;code&gt;Yellow&lt;/code&gt;, &lt;code&gt;Green&lt;/code&gt;, &lt;code&gt;Teal&lt;/code&gt;, &lt;code&gt;Accent&lt;/code&gt;, &lt;code&gt;Pink&lt;/code&gt;, &lt;code&gt;Success&lt;/code&gt;, &lt;code&gt;Warning&lt;/code&gt;, &lt;code&gt;Danger&lt;/code&gt;, and &lt;code&gt;Custom("your-inline-css")&lt;/code&gt;.&lt;/p&gt;
&lt;h3&gt;
  
  
  &lt;code&gt;Block&lt;/code&gt;
&lt;/h3&gt;


&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Leptos&lt;/span&gt;
&lt;span class="nd"&gt;view!&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Block&lt;/span&gt;
        &lt;span class="n"&gt;code&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"fn main() {&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s"&gt;    println!(&lt;/span&gt;&lt;span class="se"&gt;\"&lt;/span&gt;&lt;span class="s"&gt;Hello!&lt;/span&gt;&lt;span class="se"&gt;\"&lt;/span&gt;&lt;span class="s"&gt;);&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s"&gt;}"&lt;/span&gt;
        &lt;span class="n"&gt;language&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Language&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Rust&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
        &lt;span class="n"&gt;theme&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Theme&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;NightOwl&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Header&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Title&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="s"&gt;"main.rs"&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Title&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;LanguageBadge&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;CopyTrigger&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Header&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Content&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Block&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;The &lt;code&gt;Block&lt;/code&gt; pushes a &lt;code&gt;BlockContext&lt;/code&gt; containing &lt;code&gt;code&lt;/code&gt;, &lt;code&gt;language&lt;/code&gt;, and &lt;code&gt;theme&lt;/code&gt; into a provider tree. All child components read from context. &lt;code&gt;Content&lt;/code&gt; calls &lt;code&gt;highlight_code&lt;/code&gt; and injects the result via &lt;code&gt;inner_html&lt;/code&gt; / &lt;code&gt;dangerous_inner_html&lt;/code&gt; / &lt;code&gt;Html::from_html_unchecked&lt;/code&gt;, the framework-appropriate unsafe-but-correct escape hatch for pre-rendered HTML. No prop drilling. No callback chains. Just context.&lt;/p&gt;
&lt;h2&gt;
  
  
  8 Themes
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4d6ty5vtj0lt7in1kdso.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4d6ty5vtj0lt7in1kdso.jpeg" alt="Just right"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Theme&lt;/th&gt;
&lt;th&gt;Background&lt;/th&gt;
&lt;th&gt;Vibe&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;OneDark&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;#1a1a2e&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;The classic. Atom's gift to the world.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Dracula&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;#282a36&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Halloween every day. Pink keywords.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;NightOwl&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;#011627&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Deep blue, warm salmon numbers.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;GithubDark&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;#0d1117&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Feels like GitHub, because it is.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;GithubLight&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;#ffffff&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;For those who dare use light mode.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Solarized&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;#002b36&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Ethan Schoonover's gift to the terminal.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Monokai&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;#272822&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;The Sublime Text nostalgia trip.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Nord&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;#2e3440&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Arctic. Clean. Borderline peaceful.&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Switch themes at runtime by simply changing the &lt;code&gt;theme&lt;/code&gt; prop. The &lt;code&gt;ThemeColors&lt;/code&gt; struct drives inline style generation, every &lt;code&gt;push_span()&lt;/code&gt; call pulls the exact CSS value from the active theme's fields.&lt;/p&gt;

&lt;p&gt;Need your brand colors? &lt;code&gt;Theme::Custom(ThemeColors { keyword: "color:#ff0099;font-weight:600", ... })&lt;/code&gt; and you're done.&lt;/p&gt;
&lt;h2&gt;
  
  
  The Build Journey
&lt;/h2&gt;

&lt;p&gt;We are not going to pretend this was a relaxing weekend project. Here is an honest accounting.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsxyw4cyx4pq74mywzcze.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fsxyw4cyx4pq74mywzcze.jpeg" alt="Expectations vs Reality"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;h3&gt;
  
  
  Chapter 1: The Rust 2024 Edition
&lt;/h3&gt;

&lt;p&gt;Rust Edition 2024 changed how string-like identifiers in macro positions are parsed. The &lt;code&gt;yew::html!&lt;/code&gt; macro started rejecting class names like &lt;code&gt;text-black&lt;/code&gt; and &lt;code&gt;whitespace-pre&lt;/code&gt;, specifically the hyphen-adjacent tokens that look like prefix expressions.&lt;/p&gt;

&lt;p&gt;The error: &lt;code&gt;prefix 'black' is unknown&lt;/code&gt;. The fix: add a trailing space after the class name. Simple, but it wasted an embarrassing amount of time because the error message looks nothing like what it actually is.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Before (breaks in Edition 2024):&lt;/span&gt;
&lt;span class="n"&gt;class&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"flex text-black"&lt;/span&gt;
&lt;span class="c1"&gt;// After:&lt;/span&gt;
&lt;span class="n"&gt;class&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"flex text-black "&lt;/span&gt;  &lt;span class="c1"&gt;// ← single space, problem solved&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;h3&gt;
  
  
  Chapter 2: Dioxus RSX
&lt;/h3&gt;

&lt;p&gt;The &lt;code&gt;rsx!&lt;/code&gt; macro in Dioxus parses string prop values as format strings. So this:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="n"&gt;code&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;"fn main() {&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s"&gt;    println!(&lt;/span&gt;&lt;span class="se"&gt;\"&lt;/span&gt;&lt;span class="s"&gt;Hello!&lt;/span&gt;&lt;span class="se"&gt;\"&lt;/span&gt;&lt;span class="s"&gt;);&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s"&gt;}"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Explodes with &lt;code&gt;Failed to parse formatted segment: Expected Ident or Exp&lt;/code&gt;. Because &lt;code&gt;{&lt;/code&gt; inside a string prop is format syntax to Dioxus, not a literal curly brace.&lt;/p&gt;

&lt;p&gt;The fix: extract all code strings to &lt;code&gt;const&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;const&lt;/span&gt; &lt;span class="n"&gt;HELLO_WORLD&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="nb"&gt;str&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;"fn main() {&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s"&gt;    println!(&lt;/span&gt;&lt;span class="se"&gt;\"&lt;/span&gt;&lt;span class="s"&gt;Hello!&lt;/span&gt;&lt;span class="se"&gt;\"&lt;/span&gt;&lt;span class="s"&gt;);&lt;/span&gt;&lt;span class="se"&gt;\n&lt;/span&gt;&lt;span class="s"&gt;}"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="nd"&gt;rsx!&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;Block&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;code&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;HELLO_WORLD&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Unglamorous? Yes. But it compiles.&lt;/p&gt;
&lt;h3&gt;
  
  
  Chapter 3: The &lt;code&gt;dangerous_inner_html&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;In Dioxus, &lt;code&gt;dangerous_inner_html&lt;/code&gt; takes ownership of a &lt;code&gt;String&lt;/code&gt;. In Leptos, &lt;code&gt;inner_html&lt;/code&gt; takes a &lt;code&gt;&amp;amp;str&lt;/code&gt;. In Yew, &lt;code&gt;Html::from_html_unchecked&lt;/code&gt; takes an &lt;code&gt;AttrValue&lt;/code&gt;. Three frameworks, three signatures, three slightly different ways to inject a pre-rendered HTML string.&lt;/p&gt;

&lt;p&gt;Each one worked fine once you knew the exact type expected. Getting there required reading the framework source, not the docs, because the docs had helpfully omitted the borrow semantics.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkx1qo7k9qkr2x1cw51ob.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkx1qo7k9qkr2x1cw51ob.jpeg" alt="Fine dababy"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;h3&gt;
  
  
  Chapter 4: Non-Exhaustive &lt;code&gt;Variant::Custom&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;Adding &lt;code&gt;Custom(&amp;amp;'static str)&lt;/code&gt; to the &lt;code&gt;Variant&lt;/code&gt; enum immediately broke every match in all three &lt;code&gt;Code&lt;/code&gt; component implementations. Expected. Annoying. The fix is the following:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="nn"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;Custom&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="s"&gt;""&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;But finding all three match sites across three files while also trying to fix four other things simultaneously is exactly the kind of thing that makes you wish Rust had &lt;code&gt;#[non_exhaustive]&lt;/code&gt; as an opt-in marker you could flip during development.&lt;/p&gt;
&lt;h2&gt;
  
  
  Accessibility
&lt;/h2&gt;

&lt;p&gt;Code RS ships accessible markup out of the box:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;Block&lt;/code&gt; renders as &lt;code&gt;&amp;lt;figure role="region"&amp;gt;&lt;/code&gt; with &lt;code&gt;aria-label&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;The inner &lt;code&gt;&amp;lt;pre&amp;gt;&lt;/code&gt; gets &lt;code&gt;tabindex="0"&lt;/code&gt; so keyboard users can scroll it.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;CopyTrigger&lt;/code&gt; carries &lt;code&gt;aria-label="Copy code to clipboard"&lt;/code&gt; and &lt;code&gt;aria-live&lt;/code&gt; region feedback via the copied label swap.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;Code&lt;/code&gt; accepts &lt;code&gt;aria_label&lt;/code&gt; for use in contexts where &lt;code&gt;&amp;lt;code&amp;gt;&lt;/code&gt; alone doesn't carry enough meaning.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;LanguageBadge&lt;/code&gt; reads the language from context and renders &lt;code&gt;aria-label="Language: rust"&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Screen readers don't need to guess what anything is.&lt;/p&gt;
&lt;h2&gt;
  
  
  Quick Setup
&lt;/h2&gt;


&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Yew&lt;/span&gt;
cargo add coders &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;yew

&lt;span class="c"&gt;# Dioxus&lt;/span&gt;
cargo add coders &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;dio

&lt;span class="c"&gt;# Leptos&lt;/span&gt;
cargo add coders &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;lep
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;That's it. The syntax highlighting, theming, clipboard, and accessibility, all included. No config files. No CSS imports. No &lt;code&gt;npm install @something/highlighter-peer-dependency&lt;/code&gt;.&lt;/p&gt;
&lt;h2&gt;
  
  
  Final Thoughts
&lt;/h2&gt;

&lt;p&gt;Writing a CDN-free, pure-WASM syntax highlighter from scratch to ship alongside a composable code block component is not the most efficient path. But it's the correct one for this ecosystem.&lt;/p&gt;

&lt;p&gt;The web has enough &lt;code&gt;&amp;lt;script src="https://cdn.example.com/dep.min.js"&amp;gt;&lt;/code&gt; tags. Rust WASM doesn't need to inherit that habit.&lt;/p&gt;

&lt;p&gt;Code RS compiles to WASM, highlights code inline, and ships 8 themes without a single network request beyond your app bundle. That's the promise.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://code-rs.netlify.app" rel="noopener noreferrer"&gt;&lt;br&gt;
&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fqcspj4eqdqxf6dp022kl.png" alt="Try It Out"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwl06pc60hq9ugm11p8vp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwl06pc60hq9ugm11p8vp.png" alt="Try It"&gt;&lt;/a&gt;&lt;/p&gt;


&lt;div class="ltag-github-readme-tag"&gt;
  &lt;div class="readme-overview"&gt;
    &lt;h2&gt;
      &lt;img src="https://assets.dev.to/assets/github-logo-5a155e1f9a670af7944dd5e12375bc76ed542ea80224905ecaf878b9157cdefc.svg" alt="GitHub logo"&gt;
      &lt;a href="https://github.com/opensass" rel="noopener noreferrer"&gt;
        opensass
      &lt;/a&gt; / &lt;a href="https://github.com/opensass/coders" rel="noopener noreferrer"&gt;
        coders
      &lt;/a&gt;
    &lt;/h2&gt;
    &lt;h3&gt;
      💻 A highly customizable code component for WASM frameworks.
    &lt;/h3&gt;
  &lt;/div&gt;
  &lt;div class="ltag-github-body"&gt;
    
&lt;div id="readme" class="md"&gt;&lt;div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h1 class="heading-element"&gt;💻 Code RS&lt;/h1&gt;
&lt;/div&gt;

&lt;p&gt;&lt;a href="https://crates.io/crates/coders" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/080837a72b46befa0fe601eb51c45056406bcfd34d3ad958d75a93d7018ca951/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f762f636f64657273" alt="Crates.io"&gt;&lt;/a&gt;
&lt;a href="https://crates.io/crates/coders" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/951633484351026d612af79011b5eeae3b1e1c6580885f1084fb138e5ac87879/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f642f636f64657273" alt="Crates.io Downloads"&gt;&lt;/a&gt;
&lt;a rel="noopener noreferrer nofollow" href="https://camo.githubusercontent.com/581a82e93aeccae36e646c4b776cf252912f9f7dd4c5a0890341efd64aa7600d/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f6c2f636f64657273"&gt;&lt;img src="https://camo.githubusercontent.com/581a82e93aeccae36e646c4b776cf252912f9f7dd4c5a0890341efd64aa7600d/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f6c2f636f64657273" alt="Crates.io License"&gt;&lt;/a&gt;
&lt;a href="https://www.rust-lang.org/" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/44b045d4da6c2fd8024c8c66a350a4c8bb9c17faf50009f34dbe64c530de2454/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d616465253230776974682d527573742d3166343235662e7376673f6c6f676f3d72757374266c6f676f436f6c6f723d7768697465" alt="made-with-rust"&gt;&lt;/a&gt;
&lt;a href="https://www.rust-lang.org" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/31c82dd347f4da3b0ee4fb00bdbab1450d962c202a7f1d46feeb52cb06c634fb/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f527573742d312e38392532422d626c75652e737667" alt="Rust"&gt;&lt;/a&gt;
&lt;a href="https://github.com/opensass" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/5ca62441414bacaa54c6c6e5b68e46c76305947b6bf498c4949fc71c1b4b10dd/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d61696e7461696e65642533462d7965732d677265656e2e737667" alt="Maintenance"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://discord.gg/b5JbvHW5nv" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/1de0ff4ce5ecb14813fe0a4ae22bfb7ab081d2255bde28b216e2d3dc454524d9/68747470733a2f2f646362616467652e6c696d65732e70696e6b2f6170692f7365727665722f62354a62764857356e76" alt="Open SASS Discord"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a rel="noopener noreferrer nofollow" href="https://raw.githubusercontent.com/opensass/coders/refs/heads/main/assets/logo.png"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fraw.githubusercontent.com%2Fopensass%2Fcoders%2Frefs%2Fheads%2Fmain%2Fassets%2Flogo.png" alt="logo"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🎬 Demo&lt;/h2&gt;
&lt;/div&gt;
&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Framework&lt;/th&gt;
&lt;th&gt;Live Demo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Yew&lt;/td&gt;
&lt;td&gt;&lt;a href="https://code-rs.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dioxus&lt;/td&gt;
&lt;td&gt;&lt;a href="https://code-dio.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Leptos&lt;/td&gt;
&lt;td&gt;&lt;a href="https://code-lep.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;📜 Intro&lt;/h2&gt;

&lt;/div&gt;
&lt;p&gt;A highly customizable, accessible inline code and code-block component for WASM frameworks: Yew, Dioxus, and Leptos. Supports multiple colors, variants, sizes, copy-to-clipboard, and composable sub-components, all WCAG compliant.&lt;/p&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🤔 Why Code RS?&lt;/h2&gt;

&lt;/div&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;🎨 Fully Customizable&lt;/strong&gt;: Control every attribute, class, style, color, variant, size, ARIA labels, and more.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;📋 Copy to Clipboard&lt;/strong&gt;: Built-in copy button with a configurable confirmation label and reset timeout.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;🧩 Composable&lt;/strong&gt;: Compose &lt;code&gt;Header&lt;/code&gt;, &lt;code&gt;Title&lt;/code&gt;, &lt;code&gt;CopyTrigger&lt;/code&gt;, &lt;code&gt;Content&lt;/code&gt;, and &lt;code&gt;LanguageBadge&lt;/code&gt; independently.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;♿ Accessible by Default&lt;/strong&gt;: &lt;code&gt;role="region"&lt;/code&gt;, &lt;code&gt;aria-label&lt;/code&gt;, &lt;code&gt;aria-live&lt;/code&gt; and &lt;code&gt;tabindex&lt;/code&gt; wired up automatically.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;🔧 Framework Agnostic&lt;/strong&gt;: Same API semantics across Yew, Dioxus, and Leptos.&lt;/li&gt;
&lt;/ol&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;Y Yew Usage&lt;/h2&gt;

&lt;/div&gt;

&lt;p&gt;Refer to &lt;a href="https://github.com/opensass/coders/blob/main/YEW.md" rel="noopener noreferrer"&gt;our guide&lt;/a&gt; to integrate this component into your Yew app.&lt;/p&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🧬 Dioxus Usage&lt;/h2&gt;

&lt;/div&gt;

&lt;p&gt;Refer to &lt;a href="https://github.com/opensass/coders/blob/main/DIOXUS.md" rel="noopener noreferrer"&gt;our guide&lt;/a&gt; to integrate this component into your Dioxus app.&lt;/p&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🌱&lt;/h2&gt;…&lt;/div&gt;&lt;/div&gt;
  &lt;/div&gt;
  &lt;div class="gh-btn-container"&gt;&lt;a class="gh-btn" href="https://github.com/opensass/coders" rel="noopener noreferrer"&gt;View on GitHub&lt;/a&gt;&lt;/div&gt;
&lt;/div&gt;


&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;We are Open SASS, babe!&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;We're working tirelessly on making Rust web development extremely easy for everyone.&lt;/p&gt;

&lt;p&gt;If you made it this far, it would be nice if you could &lt;a href="https://discord.gg/b5JbvHW5nv" rel="noopener noreferrer"&gt;join us on Discord&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Till next time 👋!&lt;/p&gt;
&lt;/blockquote&gt;

</description>
      <category>webdev</category>
      <category>rust</category>
      <category>css</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>🃏 Card RS: Extremely Customizable Card component for WASM frameworks</title>
      <dc:creator>Mahmoud 🦀</dc:creator>
      <pubDate>Sun, 27 Sep 2026 11:11:08 +0000</pubDate>
      <link>https://dev.to/wiseai/card-rs-extremely-customizable-card-component-for-wasm-frameworks-1j0c</link>
      <guid>https://dev.to/wiseai/card-rs-extremely-customizable-card-component-for-wasm-frameworks-1j0c</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Salut tout le monde 👋!&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If there is one layout component that has been re-implemented more times than the &lt;code&gt;&amp;lt;button&amp;gt;&lt;/code&gt;, it's the Card. Think about it. Every widget, every dashboard panel, every pricing tier, every shiny glowing glassmorphism element you've ever seen is, deep down, a card.&lt;/p&gt;

&lt;p&gt;Instead of writing &lt;code&gt;div class="p-6 border rounded-xl shadow-lg bg-white"&lt;/code&gt; for the 5000th time, we decided to solve cards natively for WASM.&lt;/p&gt;

&lt;p&gt;Today, we're shipping &lt;a href="https://github.com/opensass/card-rs" rel="noopener noreferrer"&gt;&lt;strong&gt;Card RS&lt;/strong&gt;&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Is Card RS?
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Card RS&lt;/strong&gt; is an extremely customizable, production-ready, accessible Card component for &lt;strong&gt;Yew&lt;/strong&gt;, &lt;strong&gt;Dioxus&lt;/strong&gt;, and &lt;strong&gt;Leptos&lt;/strong&gt;. We've extracted all the tedious BEM boilerplate, flexbox wrangling, and ARIA attributes out of your templates, giving you a clean, composable API for building solid UI surfaces.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvu3cf63zifl903lhoc80.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvu3cf63zifl903lhoc80.jpeg" alt="Oprah" width="620" height="465"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Cards shouldn't be monoliths. If you just need a surface, &lt;code&gt;&amp;lt;Card&amp;gt;&lt;/code&gt; works perfectly alone. If you need standard anatomical parts, stick &lt;code&gt;&amp;lt;Header&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;Title&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;Content&amp;gt;&lt;/code&gt;, and &lt;code&gt;&amp;lt;Footer&amp;gt;&lt;/code&gt; in there.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Composable Anatomy
&lt;/h2&gt;

&lt;p&gt;The problem with most UI library cards is that they force you into a specific layout. Card RS doesn't mandate structure; it provides logical boundaries.&lt;/p&gt;

&lt;h3&gt;
  
  
  The Shell: &lt;code&gt;Card&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;The parent wrapper. It renders a clean HTML5 &lt;code&gt;&amp;lt;article&amp;gt;&lt;/code&gt; (or whatever ARIA role you need) with our default elevated styling.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;card_rs&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;yew&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Card&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;card_rs&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;yew&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;prelude&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="nd"&gt;#[function_component(MyWidget)]&lt;/span&gt;
&lt;span class="k"&gt;pub&lt;/span&gt; &lt;span class="k"&gt;fn&lt;/span&gt; &lt;span class="nf"&gt;widget&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="k"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;Html&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nd"&gt;html!&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Card&lt;/span&gt; &lt;span class="n"&gt;variant&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nb"&gt;Default&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;aria_labelledby&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"widget-title"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="c1"&gt;// the world is yours in here&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Card&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;h3&gt;
  
  
  The Skeleton: Headers, Content, &amp;amp; Footers
&lt;/h3&gt;

&lt;p&gt;Don't want to write inline styles for gaps and flex-columns? Neither do we.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Card&lt;/span&gt; &lt;span class="n"&gt;aria_labelledby&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"c-title"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Header&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Title&lt;/span&gt; &lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"c-title"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"Card Title"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Title&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Description&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"The description lives here."&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Description&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Header&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Content&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"Any content fits neatly in the main body area."&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Content&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Footer&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;button&lt;/span&gt; &lt;span class="n"&gt;aria&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Confirm"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"Confirm"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;button&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Footer&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Card&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;The header stacks title and description with precise spacing. The footer handles your action bars. Everything just snaps into place like LEGOs.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F8ljo5nnra85a7muehcx5.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F8ljo5nnra85a7muehcx5.jpeg" alt="A perfectly aligned card component" width="444" height="450"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  Variants and Prominence
&lt;/h2&gt;

&lt;p&gt;Not all cards are created equal. You need visual hierarchy. We provide a &lt;code&gt;Variant&lt;/code&gt; matrix that affects the surface depth and contrast without rewriting class strings.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;pub&lt;/span&gt; &lt;span class="k"&gt;enum&lt;/span&gt; &lt;span class="n"&gt;Variant&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;Transparent&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;  &lt;span class="c1"&gt;// No background, merges with the canvas&lt;/span&gt;
    &lt;span class="nb"&gt;Default&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;      &lt;span class="c1"&gt;// Standard surface layer&lt;/span&gt;
    &lt;span class="n"&gt;Secondary&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;    &lt;span class="c1"&gt;// Elevated and highlighted&lt;/span&gt;
    &lt;span class="n"&gt;Tertiary&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;     &lt;span class="c1"&gt;// Premium prominence (perfect for selected items)&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Building an interactive pricing selector? Wrap your iterations in a &lt;code&gt;&amp;lt;Card variant={if selected { Variant::Secondary } else { Variant::Default }}&amp;gt;&lt;/code&gt; and your hierarchy logic is done.&lt;/p&gt;
&lt;h2&gt;
  
  
  Framework Parity
&lt;/h2&gt;

&lt;p&gt;Like everything we build, &lt;strong&gt;Card RS&lt;/strong&gt; provides identical API surfaces and behavioral guarantees across all three rusty frontends:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Feature&lt;/th&gt;
&lt;th&gt;Yew&lt;/th&gt;
&lt;th&gt;Dioxus&lt;/th&gt;
&lt;th&gt;Leptos&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Card&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Header&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;Title&lt;/code&gt; &amp;amp; &lt;code&gt;Description&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;Content&lt;/code&gt; &amp;amp; &lt;code&gt;Footer&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Variant Matrix&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Accessible ARIA bindings&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Role overrides&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;If you know how to build a card in Leptos, you can build a card in Dioxus. The props are the same. The BEM classes are the same. The logic is identical.&lt;/p&gt;
&lt;h2&gt;
  
  
  Accessibility Built-In
&lt;/h2&gt;

&lt;p&gt;Accessible surfaces are often completely ignored by developers until an audit fails. &lt;strong&gt;Card RS&lt;/strong&gt; is designed strictly around WCAG guidelines.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;code&gt;Card&lt;/code&gt; renders with &lt;code&gt;role="article"&lt;/code&gt; by default.&lt;/li&gt;
&lt;li&gt;We enforce &lt;code&gt;aria_labelledby&lt;/code&gt; to tie structural landmarks to the &lt;code&gt;Title&lt;/code&gt; ID.&lt;/li&gt;
&lt;li&gt;If you want a non-interactive surface, just override it with &lt;code&gt;role="note"&lt;/code&gt; or &lt;code&gt;role="region"&lt;/code&gt;.
&lt;/li&gt;
&lt;/ol&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Accessible structural linking:&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Card&lt;/span&gt; &lt;span class="n"&gt;aria_labelledby&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"promo-heading"&lt;/span&gt; &lt;span class="n"&gt;role&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"region"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Header&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Title&lt;/span&gt; &lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"promo-heading"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"Special Offer!"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Title&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Header&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Card&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;With one prop, screen readers will now announce "Region: Special Offer!" properly.&lt;/p&gt;
&lt;h2&gt;
  
  
  Customization
&lt;/h2&gt;

&lt;p&gt;We aren't trapping you in our aesthetic. Want a weird horizontally-aligned flex-row card with a gradient background? Just use the &lt;code&gt;style&lt;/code&gt; prop. Card RS accepts your CSS strings eagerly.&lt;/p&gt;
&lt;h2&gt;
  
  
  Quick Setup
&lt;/h2&gt;

&lt;p&gt;Stop copying and pasting giant Tailwind HTML blobs. Do this instead:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Yew&lt;/span&gt;
cargo add card-rs &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;yew

&lt;span class="c"&gt;# Dioxus&lt;/span&gt;
cargo add card-rs &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;dio

&lt;span class="c"&gt;# Leptos&lt;/span&gt;
cargo add card-rs &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;lep
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;h2&gt;
  
  
  Final Thoughts
&lt;/h2&gt;

&lt;p&gt;The web is made of cards. Taking the time to unify how we create, structure, and render them across Wasm frameworks means we can stop fighting with padding and flexbox alignment, and get back to building real features.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://card-rs.netlify.app" rel="noopener noreferrer"&gt;&lt;br&gt;
&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fqcspj4eqdqxf6dp022kl.png" alt="Try It Out" width="215" height="66"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwl06pc60hq9ugm11p8vp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwl06pc60hq9ugm11p8vp.png" alt="Try It" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;


&lt;div class="ltag-github-readme-tag"&gt;
  &lt;div class="readme-overview"&gt;
    &lt;h2&gt;
      &lt;img src="https://assets.dev.to/assets/github-logo-5a155e1f9a670af7944dd5e12375bc76ed542ea80224905ecaf878b9157cdefc.svg" alt="GitHub logo"&gt;
      &lt;a href="https://github.com/opensass" rel="noopener noreferrer"&gt;
        opensass
      &lt;/a&gt; / &lt;a href="https://github.com/opensass/card-rs" rel="noopener noreferrer"&gt;
        card-rs
      &lt;/a&gt;
    &lt;/h2&gt;
    &lt;h3&gt;
      🃏 A highly customizable card component for WASM frameworks
    &lt;/h3&gt;
  &lt;/div&gt;
  &lt;div class="ltag-github-body"&gt;
    
&lt;div id="readme" class="md"&gt;&lt;div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h1 class="heading-element"&gt;🃏 Card RS&lt;/h1&gt;
&lt;/div&gt;

&lt;p&gt;&lt;a href="https://crates.io/crates/card-rs" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/aec4d66c1d0cd22f203c1693dffa539fdcd1c4dda9548c3093c862ad2163ffd2/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f762f636172642d7273" alt="Crates.io"&gt;&lt;/a&gt;
&lt;a href="https://crates.io/crates/card-rs" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/05a0e33232aa5c81b38cf2783119f721dae363ffefe6bfb20fe7d99df024d69d/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f642f636172642d7273" alt="Crates.io Downloads"&gt;&lt;/a&gt;
&lt;a rel="noopener noreferrer nofollow" href="https://camo.githubusercontent.com/acb28f424a370815c5e608ac242d84568744323542f9dd96477cf3634b73be26/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f6c2f636172642d7273"&gt;&lt;img src="https://camo.githubusercontent.com/acb28f424a370815c5e608ac242d84568744323542f9dd96477cf3634b73be26/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f6c2f636172642d7273" alt="Crates.io License"&gt;&lt;/a&gt;
&lt;a href="https://www.rust-lang.org/" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/44b045d4da6c2fd8024c8c66a350a4c8bb9c17faf50009f34dbe64c530de2454/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d616465253230776974682d527573742d3166343235662e7376673f6c6f676f3d72757374266c6f676f436f6c6f723d7768697465" alt="made-with-rust"&gt;&lt;/a&gt;
&lt;a href="https://www.rust-lang.org" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/31c82dd347f4da3b0ee4fb00bdbab1450d962c202a7f1d46feeb52cb06c634fb/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f527573742d312e38392532422d626c75652e737667" alt="Rust"&gt;&lt;/a&gt;
&lt;a href="https://github.com/opensass" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/5ca62441414bacaa54c6c6e5b68e46c76305947b6bf498c4949fc71c1b4b10dd/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d61696e7461696e65642533462d7965732d677265656e2e737667" alt="Maintenance"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://discord.gg/b5JbvHW5nv" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/1de0ff4ce5ecb14813fe0a4ae22bfb7ab081d2255bde28b216e2d3dc454524d9/68747470733a2f2f646362616467652e6c696d65732e70696e6b2f6170692f7365727665722f62354a62764857356e76" alt="Open SASS Discord"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a rel="noopener noreferrer nofollow" href="https://raw.githubusercontent.com/opensass/card-rs/refs/heads/main/assets/logo.png"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fraw.githubusercontent.com%2Fopensass%2Fcard-rs%2Frefs%2Fheads%2Fmain%2Fassets%2Flogo.png" alt="logo"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🎬 Demo&lt;/h2&gt;
&lt;/div&gt;
&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Framework&lt;/th&gt;
&lt;th&gt;Live Demo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Yew&lt;/td&gt;
&lt;td&gt;&lt;a href="https://card-rs.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dioxus&lt;/td&gt;
&lt;td&gt;&lt;a href="https://card-dio.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Leptos&lt;/td&gt;
&lt;td&gt;&lt;a href="https://card-lep.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;📜 Intro&lt;/h2&gt;

&lt;/div&gt;
&lt;p&gt;A highly customizable, accessible card component for WASM frameworks: Yew, Dioxus, and Leptos.
Supports semantic prominence variants, composable sub-components (header, title, description,
content, footer), and full WCAG compliance.&lt;/p&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🤔 Why Card RS?&lt;/h2&gt;

&lt;/div&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;🎨 Fully Customizable&lt;/strong&gt;: Control variant, class, style, ARIA labels, and every sub-component attribute.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;🧩 Composable API&lt;/strong&gt;: Use &lt;code&gt;Card&lt;/code&gt;, &lt;code&gt;Header&lt;/code&gt;, &lt;code&gt;Title&lt;/code&gt;, &lt;code&gt;Description&lt;/code&gt;, &lt;code&gt;Content&lt;/code&gt;, and &lt;code&gt;Footer&lt;/code&gt; independently or together.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;🏷️ Semantic Variants&lt;/strong&gt;: &lt;code&gt;transparent&lt;/code&gt;, &lt;code&gt;default&lt;/code&gt;, &lt;code&gt;secondary&lt;/code&gt;, &lt;code&gt;tertiary&lt;/code&gt;, themes interpret prominence without hard-coded colors.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;♿ Accessible by Default&lt;/strong&gt;: &lt;code&gt;role="article"&lt;/code&gt;, &lt;code&gt;aria-labelledby&lt;/code&gt;, and &lt;code&gt;aria-label&lt;/code&gt; wired up automatically.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;🔧 Framework Agnostic&lt;/strong&gt;: Same API semantics across Yew, Dioxus, and Leptos.&lt;/li&gt;
&lt;/ol&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;Y Yew Usage&lt;/h2&gt;

&lt;/div&gt;

&lt;p&gt;Refer to &lt;a href="https://github.com/opensass/card-rs/blob/main/YEW.md" rel="noopener noreferrer"&gt;our guide&lt;/a&gt; to integrate this component into your Yew app.&lt;/p&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🧬 Dioxus Usage&lt;/h2&gt;

&lt;/div&gt;

&lt;p&gt;Refer to &lt;a href="https://github.com/opensass/card-rs/blob/main/DIOXUS.md" rel="noopener noreferrer"&gt;our guide&lt;/a&gt; to integrate this component into…&lt;/p&gt;&lt;/div&gt;
  &lt;/div&gt;
  &lt;div class="gh-btn-container"&gt;&lt;a class="gh-btn" href="https://github.com/opensass/card-rs" rel="noopener noreferrer"&gt;View on GitHub&lt;/a&gt;&lt;/div&gt;
&lt;/div&gt;


&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;We are Open SASS, babe!&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;We're working tirelessly on making Rust web development extremely easy for everyone.&lt;/p&gt;

&lt;p&gt;If you made it this far, it would be nice if you could &lt;a href="https://discord.gg/b5JbvHW5nv" rel="noopener noreferrer"&gt;join us on Discord&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Till next time 👋!&lt;/p&gt;
&lt;/blockquote&gt;

</description>
      <category>rust</category>
      <category>webdev</category>
      <category>css</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>🔴 Badge RS: Easy to Use Badge Components for WASM Frameworks</title>
      <dc:creator>Mahmoud 🦀</dc:creator>
      <pubDate>Sun, 27 Sep 2026 11:08:44 +0000</pubDate>
      <link>https://dev.to/wiseai/badge-rs-easy-to-use-badge-components-for-wasm-frameworks-4p3k</link>
      <guid>https://dev.to/wiseai/badge-rs-easy-to-use-badge-components-for-wasm-frameworks-4p3k</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Je vous salue 👋!&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Every WASM app eventually needs a badge. The little red circle on your notification bell. The green dot on the corner of an avatar. The "99+" that taunts you every morning from the inbox icon. They're everywhere, and somehow everyone is still hand-rolling them.&lt;/p&gt;

&lt;p&gt;That stops today. We're shipping &lt;a href="https://github.com/opensass/badges-rs" rel="noopener noreferrer"&gt;&lt;strong&gt;Badge RS&lt;/strong&gt;&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Is Badge RS?
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Badge RS&lt;/strong&gt; is a production-ready badge component for &lt;strong&gt;Yew&lt;/strong&gt;, &lt;strong&gt;Dioxus&lt;/strong&gt;, and &lt;strong&gt;Leptos&lt;/strong&gt;. Notification counters, status dots, overflow labels, the whole catalogue. It handles positioning, sizing, color theming, dot mode, accessible markup, and even knows the difference between a circle and a rectangle.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqfqp34vjjcwdd8132hhj.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqfqp34vjjcwdd8132hhj.jpeg" alt="one does not simply center a badge on a circular avatar" width="651" height="384"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;If you've ever opened your browser devtools at 11pm trying to figure out why a badge is floating 4px off the corner of an avatar instead of sitting flush on the arc, Badge RS is the component you wish had existed.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Core Components
&lt;/h2&gt;

&lt;h3&gt;
  
  
  &lt;code&gt;Anchor&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;The positioning wrapper. Drop it around any element and it becomes a badge target. Uses &lt;code&gt;position: relative; display: inline-flex;&lt;/code&gt; so it doesn't break your layout, doesn't eat your accessibility tree, and doesn't require you to memorize any CSS tricks.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;badges_rs&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;yew&lt;/span&gt;&lt;span class="p"&gt;::{&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Anchor&lt;/span&gt;&lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;badges_rs&lt;/span&gt;&lt;span class="p"&gt;::{&lt;/span&gt;&lt;span class="n"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Shape&lt;/span&gt;&lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;yew&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;prelude&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="nd"&gt;#[function_component(NotificationBell)]&lt;/span&gt;
&lt;span class="k"&gt;pub&lt;/span&gt; &lt;span class="k"&gt;fn&lt;/span&gt; &lt;span class="nf"&gt;notification_bell&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="k"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;Html&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nd"&gt;html!&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Anchor&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;span&lt;/span&gt; &lt;span class="n"&gt;aria&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Inbox, 5 unread messages"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"📬"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;span&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt;
                &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Danger&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
                &lt;span class="n"&gt;shape&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Shape&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Circle&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
                &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"5 unread messages"&lt;/span&gt;
            &lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
                &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"5"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Anchor&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;That's it. The badge positions itself. You decide where.&lt;/p&gt;
&lt;h3&gt;
  
  
  &lt;code&gt;Badge&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;The actual indicator. Pass children and you get a labeled badge with text inside. Skip children and you get a compact do, no extra prop needed, just don't put anything inside.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// A labeled count badge&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Danger&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;size&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Sm&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"5 unread"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"5"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;

&lt;span class="c1"&gt;// A status dot, no children, no extra prop&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Success&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;placement&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Placement&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;BottomRight&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Online"&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Same component, two modes. The dot is not a separate component.&lt;/p&gt;
&lt;h3&gt;
  
  
  &lt;code&gt;BadgeLabel&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;A thin &lt;code&gt;&amp;lt;span class="badge__label"&amp;gt;&lt;/code&gt; wrapper. Used automatically when you pass plain text to &lt;code&gt;Badge&lt;/code&gt;. Expose it directly when you need extra CSS classes or styling on the label slot.&lt;/p&gt;
&lt;h2&gt;
  
  
  Colors, Variants, Sizes
&lt;/h2&gt;

&lt;p&gt;The full set of knobs is available:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Colors&lt;/span&gt;
&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nb"&gt;Default&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Accent&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Success&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Warning&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Danger&lt;/span&gt;

&lt;span class="c1"&gt;// Variants (three visual styles)&lt;/span&gt;
&lt;span class="nn"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Primary&lt;/span&gt;    &lt;span class="c1"&gt;// solid fill&lt;/span&gt;
&lt;span class="nn"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Secondary&lt;/span&gt;  &lt;span class="c1"&gt;// outlined&lt;/span&gt;
&lt;span class="nn"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Soft&lt;/span&gt;       &lt;span class="c1"&gt;// muted, lower-contrast&lt;/span&gt;

&lt;span class="c1"&gt;// Sizes&lt;/span&gt;
&lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Sm&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Md&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Lg&lt;/span&gt;

&lt;span class="c1"&gt;// Placement&lt;/span&gt;
&lt;span class="nn"&gt;Placement&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;TopRight&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Placement&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;TopLeft&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Placement&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;BottomRight&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Placement&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;BottomLeft&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;All combinations work. TopLeft is there for RTL layouts and anyone who likes to be contrarian about badge placement.&lt;/p&gt;
&lt;h2&gt;
  
  
  The Positioning Bug Nobody Talks About
&lt;/h2&gt;

&lt;p&gt;Here's the subtle one. &lt;code&gt;top: 0; right: 0&lt;/code&gt; with &lt;code&gt;transform: translate(50%, -50%)&lt;/code&gt; centers a badge perfectly on the corner of a &lt;strong&gt;rectangle&lt;/strong&gt;. That's fine for icon buttons, list items, or anything with a square bounding box.&lt;/p&gt;

&lt;p&gt;For a &lt;strong&gt;circle&lt;/strong&gt;, which is what every avatar in existence is, the story is different. A circle's actual edge at 45° sits inward from the bounding box corner. The geometric offset is exactly &lt;code&gt;1 - sin(45°)&lt;/code&gt;, which works out to roughly &lt;strong&gt;14.64%&lt;/strong&gt; of the element's width and height.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9u5nnmj96400cbtbwqwn.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9u5nnmj96400cbtbwqwn.jpeg" alt="math lady" width="681" height="445"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Most badge implementations ignore this. The badge floats slightly off the arc, nobody files a bug, and the designer quietly seethes.&lt;/p&gt;

&lt;p&gt;Badge RS exposes a &lt;code&gt;Shape&lt;/code&gt; enum to handle this explicitly:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;pub&lt;/span&gt; &lt;span class="k"&gt;enum&lt;/span&gt; &lt;span class="n"&gt;Shape&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;Rectangle&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;  &lt;span class="c1"&gt;// top: 0; right: 0, standard bounding box corner&lt;/span&gt;
    &lt;span class="n"&gt;Circle&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;     &lt;span class="c1"&gt;// top: 14.64%; right: 14.64%, sits on the arc&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// On a circular avatar, badge sits flush on the arc:&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Danger&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;shape&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Shape&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Circle&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"3"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"3"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;

&lt;span class="c1"&gt;// On a square icon button, badge sits on the bounding box corner:&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Accent&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;shape&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Shape&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Rectangle&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"New"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"New"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;The math is not magic. It's just trigonometry that nobody wanted to look up at 11pm. We looked it up for you.&lt;/p&gt;
&lt;h2&gt;
  
  
  Framework Parity
&lt;/h2&gt;

&lt;p&gt;All three frameworks ship the same API surface:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Feature&lt;/th&gt;
&lt;th&gt;Yew&lt;/th&gt;
&lt;th&gt;Dioxus&lt;/th&gt;
&lt;th&gt;Leptos&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Anchor&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Badge&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;BadgeLabel&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;Shape::Circle&lt;/code&gt; offset&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dot mode (no children)&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;All placements&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;All variants&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ARIA attributes&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;If you've used it in Yew, you already know how to use it in Dioxus and Leptos. The prop names don't even change.&lt;/p&gt;
&lt;h2&gt;
  
  
  Accessibility
&lt;/h2&gt;

&lt;p&gt;Accessible badges are an afterthought in most libraries. In Badge RS they're mandatory.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;Badge&lt;/code&gt; renders with &lt;code&gt;role="status"&lt;/code&gt; and a required &lt;code&gt;aria_label&lt;/code&gt;. Screen readers announce the content without the user having to navigate to it.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;aria-atomic="true"&lt;/code&gt; ensures the full label is re-read when the count updates. A badge that goes from "3" to "4" reads "4 unread messages", not just "4".&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;Anchor&lt;/code&gt; renders as a &lt;code&gt;&amp;lt;span&amp;gt;&lt;/code&gt; with no ARIA role, because it's structural glue and should be invisible to assistive technology.&lt;/li&gt;
&lt;li&gt;The WCAG guidance on badges is straightforward: &lt;strong&gt;label the element that owns the badge, not just the badge itself&lt;/strong&gt;. We mention this in the docs and the examples follow it throughout.
&lt;/li&gt;
&lt;/ul&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// The accessible way, the host element's label includes the count&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;span&lt;/span&gt; &lt;span class="n"&gt;aria&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Inbox, 5 unread messages"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"📬"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;span&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt; &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"5 unread messages"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"5"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;The badge label and the host's aria-label should tell the same story from different angles.&lt;/p&gt;
&lt;h2&gt;
  
  
  Quick Setup
&lt;/h2&gt;


&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Yew&lt;/span&gt;
cargo add badges-rs &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;yew

&lt;span class="c"&gt;# Dioxus&lt;/span&gt;
cargo add badges-rs &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;dio

&lt;span class="c"&gt;# Leptos&lt;/span&gt;
cargo add badges-rs &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;lep
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;No CSS framework required. Styles are computed inline from the prop values.&lt;/p&gt;
&lt;h2&gt;
  
  
  Dot Mode vs Count Mode
&lt;/h2&gt;

&lt;p&gt;One component, two modes, no separate component for each. This matters because it keeps your import surface small and your mental model consistent.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Count mode, children present&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Danger&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"5 messages"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"5"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;

&lt;span class="c1"&gt;// Dot mode, no children, badge renders as a small filled circle&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Success&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;placement&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Placement&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;BottomRight&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Online"&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;The dot is a first-class mode with its own size calculations. &lt;code&gt;Size::Sm&lt;/code&gt; in dot mode renders a 6×6px dot. In count mode, it renders a 16×16px pill. The size label refers to the visual weight, not a fixed pixel value.&lt;/p&gt;
&lt;h2&gt;
  
  
  Status Indicators
&lt;/h2&gt;

&lt;p&gt;The placement prop combined with dot mode covers the most common avatar status pattern:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;badges_rs&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;leptos&lt;/span&gt;&lt;span class="p"&gt;::{&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Anchor&lt;/span&gt;&lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;badges_rs&lt;/span&gt;&lt;span class="p"&gt;::{&lt;/span&gt;&lt;span class="n"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Placement&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Shape&lt;/span&gt;&lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;leptos&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;prelude&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="nd"&gt;#[component]&lt;/span&gt;
&lt;span class="k"&gt;pub&lt;/span&gt; &lt;span class="k"&gt;fn&lt;/span&gt; &lt;span class="nf"&gt;UserAvatar&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="k"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="k"&gt;impl&lt;/span&gt; &lt;span class="n"&gt;IntoView&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nd"&gt;view!&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Anchor&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;span&lt;/span&gt;
                &lt;span class="n"&gt;style&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"/* your avatar CSS */"&lt;/span&gt;
                &lt;span class="n"&gt;aria&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Jane Doe, online"&lt;/span&gt;
            &lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
                &lt;span class="s"&gt;"JD"&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;span&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Badge&lt;/span&gt;
                &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Success&lt;/span&gt;
                &lt;span class="n"&gt;shape&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nn"&gt;Shape&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Circle&lt;/span&gt;
                &lt;span class="n"&gt;placement&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="nn"&gt;Placement&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;BottomRight&lt;/span&gt;
                &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Online"&lt;/span&gt;
            &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Anchor&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Green dot, bottom-right, perfectly on the arc. That's the whole pattern.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxjso8jyvkbxme41vjc0n.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxjso8jyvkbxme41vjc0n.jpeg" alt="it works, deploy it" width="447" height="447"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  What We Didn't Do
&lt;/h2&gt;

&lt;p&gt;No magic threshold that auto-truncates to "99+". That's application logic, not component logic. We show whatever you pass in. If you want &lt;code&gt;count.min(99).to_string()&lt;/code&gt; or &lt;code&gt;"99+"&lt;/code&gt;, that's two lines in your own code.&lt;/p&gt;

&lt;p&gt;No auto-detection of the parent element's shape. That would require measuring the DOM at runtime, which is expensive. Instead: explicit &lt;code&gt;shape&lt;/code&gt; prop. You know your own design system. Tell us.&lt;/p&gt;

&lt;p&gt;No CSS injection. No global stylesheet to import. No BEM class naming conventions to memorize. The styles live on the element.&lt;/p&gt;
&lt;h2&gt;
  
  
  Final Thoughts
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Badge RS&lt;/strong&gt; is compact by design. Three components, one enum, one positioning decision that most libraries get wrong.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;Shape&lt;/code&gt; prop is the detail worth remembering. If you're putting badges on circular avatars and they look slightly off, that's the fix. Try &lt;code&gt;Shape::Circle&lt;/code&gt; and stop adjusting pixel offsets in your component stylesheets.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://badges-rs.netlify.app" rel="noopener noreferrer"&gt;&lt;br&gt;
&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fqcspj4eqdqxf6dp022kl.png" alt="Try It Out" width="215" height="66"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwl06pc60hq9ugm11p8vp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwl06pc60hq9ugm11p8vp.png" alt="Try It" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;


&lt;div class="ltag-github-readme-tag"&gt;
  &lt;div class="readme-overview"&gt;
    &lt;h2&gt;
      &lt;img src="https://assets.dev.to/assets/github-logo-5a155e1f9a670af7944dd5e12375bc76ed542ea80224905ecaf878b9157cdefc.svg" alt="GitHub logo"&gt;
      &lt;a href="https://github.com/opensass" rel="noopener noreferrer"&gt;
        opensass
      &lt;/a&gt; / &lt;a href="https://github.com/opensass/badges-rs" rel="noopener noreferrer"&gt;
        badges-rs
      &lt;/a&gt;
    &lt;/h2&gt;
    &lt;h3&gt;
      🏷️ A highly customizable badge component for WASM frameworks.
    &lt;/h3&gt;
  &lt;/div&gt;
  &lt;div class="ltag-github-body"&gt;
    
&lt;div id="readme" class="md"&gt;&lt;div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h1 class="heading-element"&gt;🏷️ Badges RS&lt;/h1&gt;
&lt;/div&gt;

&lt;p&gt;&lt;a href="https://crates.io/crates/badges-rs" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/5e2f7d8b4cee002d878621939ed713f3232ef4489b55a84b96a3f4912e20847d/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f762f6261646765732d7273" alt="Crates.io"&gt;&lt;/a&gt;
&lt;a href="https://crates.io/crates/badges-rs" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/2bece83e83e1570bf59f69764afed53a9b45a04640519f7f47f90994ae34b1d2/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f642f6261646765732d7273" alt="Crates.io Downloads"&gt;&lt;/a&gt;
&lt;a rel="noopener noreferrer nofollow" href="https://camo.githubusercontent.com/a9cc2654773e402fc68cb216f1e855aee03925e8d599a60a9118ec7ded24a306/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f6c2f6261646765732d7273"&gt;&lt;img src="https://camo.githubusercontent.com/a9cc2654773e402fc68cb216f1e855aee03925e8d599a60a9118ec7ded24a306/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f6c2f6261646765732d7273" alt="Crates.io License"&gt;&lt;/a&gt;
&lt;a href="https://www.rust-lang.org/" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/44b045d4da6c2fd8024c8c66a350a4c8bb9c17faf50009f34dbe64c530de2454/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d616465253230776974682d527573742d3166343235662e7376673f6c6f676f3d72757374266c6f676f436f6c6f723d7768697465" alt="made-with-rust"&gt;&lt;/a&gt;
&lt;a href="https://www.rust-lang.org" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/31c82dd347f4da3b0ee4fb00bdbab1450d962c202a7f1d46feeb52cb06c634fb/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f527573742d312e38392532422d626c75652e737667" alt="Rust"&gt;&lt;/a&gt;
&lt;a href="https://github.com/opensass" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/5ca62441414bacaa54c6c6e5b68e46c76305947b6bf498c4949fc71c1b4b10dd/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d61696e7461696e65642533462d7965732d677265656e2e737667" alt="Maintenance"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://discord.gg/b5JbvHW5nv" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/1de0ff4ce5ecb14813fe0a4ae22bfb7ab081d2255bde28b216e2d3dc454524d9/68747470733a2f2f646362616467652e6c696d65732e70696e6b2f6170692f7365727665722f62354a62764857356e76" alt="Open SASS Discord"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a rel="noopener noreferrer nofollow" href="https://raw.githubusercontent.com/opensass/badges-rs/refs/heads/main/assets/logo.png"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fraw.githubusercontent.com%2Fopensass%2Fbadges-rs%2Frefs%2Fheads%2Fmain%2Fassets%2Flogo.png" alt="logo"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🎬 Demo&lt;/h2&gt;
&lt;/div&gt;
&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Framework&lt;/th&gt;
&lt;th&gt;Live Demo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Yew&lt;/td&gt;
&lt;td&gt;&lt;a href="https://badges-rs.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dioxus&lt;/td&gt;
&lt;td&gt;&lt;a href="https://badges-dio.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Leptos&lt;/td&gt;
&lt;td&gt;&lt;a href="https://badges-lep.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;📜 Intro&lt;/h2&gt;

&lt;/div&gt;
&lt;p&gt;A highly customizable, accessible badge component for WASM frameworks: Yew, Dioxus, and Leptos.
Supports notification counts, status dots, labels, multiple colors, variants, sizes, and placements
with full WCAG compliance.&lt;/p&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🤔 Why Badges RS?&lt;/h2&gt;

&lt;/div&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;🎨 Fully Customizable&lt;/strong&gt;: Control color, variant, size, placement, class, style, and ARIA labels.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;🔴 Dot Mode&lt;/strong&gt;: When no children are provided the badge renders as a compact status dot.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;📍 Smart Placement&lt;/strong&gt;: Four corner placements (&lt;code&gt;top-right&lt;/code&gt;, &lt;code&gt;top-left&lt;/code&gt;, &lt;code&gt;bottom-right&lt;/code&gt;, &lt;code&gt;bottom-left&lt;/code&gt;) via CSS &lt;code&gt;transform&lt;/code&gt; for pixel-perfect positioning.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;♿ Accessible by Default&lt;/strong&gt;: &lt;code&gt;role="status"&lt;/code&gt;, &lt;code&gt;aria-label&lt;/code&gt;, and &lt;code&gt;aria-atomic&lt;/code&gt; wired up automatically.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;🧩 Framework Agnostic&lt;/strong&gt;: Same API semantics across Yew, Dioxus, and Leptos.&lt;/li&gt;
&lt;/ol&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;Y Yew Usage&lt;/h2&gt;

&lt;/div&gt;

&lt;p&gt;Refer to &lt;a href="https://github.com/opensass/badges-rs/blob/main/YEW.md" rel="noopener noreferrer"&gt;our guide&lt;/a&gt; to integrate this component into your Yew app.&lt;/p&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🧬 Dioxus Usage&lt;/h2&gt;

&lt;/div&gt;

&lt;p&gt;Refer to &lt;a href="https://github.com/opensass/badges-rs/blob/main/DIOXUS.md" rel="noopener noreferrer"&gt;our guide&lt;/a&gt; to integrate this…&lt;/p&gt;&lt;/div&gt;
  &lt;/div&gt;
  &lt;div class="gh-btn-container"&gt;&lt;a class="gh-btn" href="https://github.com/opensass/badges-rs" rel="noopener noreferrer"&gt;View on GitHub&lt;/a&gt;&lt;/div&gt;
&lt;/div&gt;


&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;We are Open SASS, babe!&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;We're working tirelessly on making Rust web development extremely easy for everyone.&lt;/p&gt;

&lt;p&gt;If you made it this far, it would be nice if you could &lt;a href="https://discord.gg/b5JbvHW5nv" rel="noopener noreferrer"&gt;join us on Discord&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Till next time 👋!&lt;/p&gt;
&lt;/blockquote&gt;

</description>
      <category>rust</category>
      <category>css</category>
      <category>typescript</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>🪪 Avatar RS: Very Efficient Avatar Components for WASM Frameworks</title>
      <dc:creator>Mahmoud 🦀</dc:creator>
      <pubDate>Sun, 27 Sep 2026 11:01:40 +0000</pubDate>
      <link>https://dev.to/wiseai/avatar-rs-very-efficient-avatar-components-for-wasm-frameworks-3lkn</link>
      <guid>https://dev.to/wiseai/avatar-rs-very-efficient-avatar-components-for-wasm-frameworks-3lkn</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;Bien le bonjour 👋!&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Every WASM app eventually needs an avatar. Profile pictures, user cards, comment threads, they're everywhere. And every time, developers end up rolling the same &lt;code&gt;&amp;lt;img&amp;gt;&lt;/code&gt; tag with some fallback logic, hardcoded border-radius, and a prayer that the CDN doesn't return a 404.&lt;/p&gt;

&lt;p&gt;That stops today. We're shipping &lt;a href="https://github.com/opensass/avatar" rel="noopener noreferrer"&gt;&lt;strong&gt;Avatar RS&lt;/strong&gt;&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Is Avatar RS?
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Avatar RS&lt;/strong&gt; is a fully-featured avatar component for &lt;strong&gt;Yew&lt;/strong&gt;, &lt;strong&gt;Dioxus&lt;/strong&gt;, and &lt;strong&gt;Leptos&lt;/strong&gt;. It handles image loading, fallback text/icons, overflow groups, color themes, size variants, accessible markup, the whole thing. Built on top of &lt;a href="https://github.com/opensass/image-rs" rel="noopener noreferrer"&gt;&lt;strong&gt;Image RS&lt;/strong&gt;&lt;/a&gt;, which means you get smart lazy loading, blur-up placeholders, and responsive layouts for free.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fw6aanc5ty0p9osk1356c.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fw6aanc5ty0p9osk1356c.jpeg" alt="one does not simply roll their own avatar component" width="651" height="384"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Think of it as the avatar component you'd build if you had infinite time and zero deadlines. We had neither, but here we are anyway.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Stack Under the Hood
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Avatar RS&lt;/strong&gt; wraps &lt;strong&gt;Image RS&lt;/strong&gt;, our WASM-native image primitive, for the actual &lt;code&gt;&amp;lt;img&amp;gt;&lt;/code&gt; element. This is not a trivial detail.&lt;/p&gt;

&lt;p&gt;Image RS uses &lt;a href="https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API" rel="noopener noreferrer"&gt;Intersection Observer API&lt;/a&gt; for lazy loading, supports &lt;code&gt;srcset&lt;/code&gt;/&lt;code&gt;sizes&lt;/code&gt; for responsive images, and fires clean &lt;code&gt;on_load&lt;/code&gt; / &lt;code&gt;on_error&lt;/code&gt; callbacks. All of that comes for free inside every &lt;code&gt;Image&lt;/code&gt; you render. The avatar layer only adds &lt;strong&gt;context management&lt;/strong&gt; and &lt;strong&gt;state coordination&lt;/strong&gt; on top.&lt;/p&gt;

&lt;h2&gt;
  
  
  Core Components
&lt;/h2&gt;

&lt;h3&gt;
  
  
  &lt;code&gt;Avatar&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;The container. Wraps &lt;code&gt;Image&lt;/code&gt; and &lt;code&gt;Fallback&lt;/code&gt;, provides the shared loading context, and inherits size/color/variant from a surrounding &lt;code&gt;Group&lt;/code&gt; if present.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;avatar&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;yew&lt;/span&gt;&lt;span class="p"&gt;::{&lt;/span&gt;&lt;span class="n"&gt;Avatar&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Image&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Fallback&lt;/span&gt;&lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;avatar&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;yew&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;prelude&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="nd"&gt;#[function_component(MyProfile)]&lt;/span&gt;
&lt;span class="k"&gt;pub&lt;/span&gt; &lt;span class="k"&gt;fn&lt;/span&gt; &lt;span class="nf"&gt;my_profile&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="k"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;Html&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nd"&gt;html!&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Avatar&lt;/span&gt; &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Ferris Prophet"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Image&lt;/span&gt;
                &lt;span class="n"&gt;src&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"https://i.pravatar.cc/300"&lt;/span&gt;
                &lt;span class="n"&gt;alt&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Ferris Prophet"&lt;/span&gt;
            &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Fallback&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nf"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Accent&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"JD"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Fallback&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Avatar&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;The fallback shows while the image loads, hides once it lands.&lt;/p&gt;
&lt;h3&gt;
  
  
  &lt;code&gt;Fallback&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;Text initials, an icon, or anything you want rendered when the image hasn't loaded yet (or doesn't exist at all). Supports a &lt;code&gt;delay_ms&lt;/code&gt; prop to intentionally delay reveal, useful when your image usually loads fast and you don't want the fallback to flash briefly then disappear.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Fallback shows immediately:&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Fallback&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nf"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Success&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"MH"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Fallback&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;

&lt;span class="c1"&gt;// Fallback waits 200ms before appearing (prevents flicker on fast connections):&lt;/span&gt;
&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Fallback&lt;/span&gt; &lt;span class="n"&gt;delay_ms&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="mi"&gt;200&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nf"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Accent&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"JD"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Fallback&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Small prop, big UX difference.&lt;/p&gt;
&lt;h3&gt;
  
  
  &lt;code&gt;Group&lt;/code&gt;
&lt;/h3&gt;

&lt;p&gt;Stack multiple avatars with automatic overlap, configurable max count, and an overflow badge showing how many more there are.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;avatar&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;yew&lt;/span&gt;&lt;span class="p"&gt;::{&lt;/span&gt;&lt;span class="n"&gt;Avatar&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Group&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Count&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Image&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Fallback&lt;/span&gt;&lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;avatar&lt;/span&gt;&lt;span class="p"&gt;::{&lt;/span&gt;&lt;span class="n"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="k"&gt;use&lt;/span&gt; &lt;span class="nn"&gt;yew&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nn"&gt;prelude&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="nd"&gt;#[function_component(TeamStack)]&lt;/span&gt;
&lt;span class="k"&gt;pub&lt;/span&gt; &lt;span class="k"&gt;fn&lt;/span&gt; &lt;span class="nf"&gt;team_stack&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="k"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;Html&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nd"&gt;html!&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Group&lt;/span&gt;
            &lt;span class="n"&gt;size&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Lg&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
            &lt;span class="n"&gt;max&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nf"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;
            &lt;span class="n"&gt;total&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nf"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;6&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;
            &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Project team"&lt;/span&gt;
        &lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Avatar&lt;/span&gt; &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Member 1"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
                &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Image&lt;/span&gt; &lt;span class="n"&gt;src&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"https://i.pravatar.cc/150?u=m1"&lt;/span&gt; &lt;span class="n"&gt;alt&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Member 1"&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
                &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Fallback&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nf"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Accent&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"M1"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Fallback&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Avatar&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Avatar&lt;/span&gt; &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Member 2"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
                &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Image&lt;/span&gt; &lt;span class="n"&gt;src&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"https://i.pravatar.cc/150?u=m2"&lt;/span&gt; &lt;span class="n"&gt;alt&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Member 2"&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
                &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Fallback&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nf"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Success&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"M2"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Fallback&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Avatar&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Avatar&lt;/span&gt; &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Member 3"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
                &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Image&lt;/span&gt; &lt;span class="n"&gt;src&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"https://i.pravatar.cc/150?u=m3"&lt;/span&gt; &lt;span class="n"&gt;alt&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"Member 3"&lt;/span&gt; &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
                &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Fallback&lt;/span&gt; &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nf"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Warning&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;"M3"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Fallback&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Avatar&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
            &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Count&lt;/span&gt;
                &lt;span class="n"&gt;color&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nf"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Danger&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;
                &lt;span class="n"&gt;variant&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nf"&gt;Some&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nn"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Soft&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;
                &lt;span class="n"&gt;aria_label&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s"&gt;"3 more members"&lt;/span&gt;
            &lt;span class="o"&gt;/&amp;gt;&lt;/span&gt;
        &lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;Group&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Pass &lt;code&gt;max={Some(3)}&lt;/code&gt; and &lt;code&gt;total={Some(6)}&lt;/code&gt;, and &lt;code&gt;Count&lt;/code&gt; automatically shows &lt;code&gt;+3&lt;/code&gt;. The math is done for you. The CSS overlap is done for you. You just write components.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fktuzlbhytd3023ywcg7d.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fktuzlbhytd3023ywcg7d.jpeg" alt="math lady" width="681" height="445"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  The &lt;code&gt;overflow_count&lt;/code&gt; Context
&lt;/h2&gt;

&lt;p&gt;This is the part that required actual thought.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;Group&lt;/code&gt; computes &lt;code&gt;overflow_count = total - max&lt;/code&gt; and pushes it into context. &lt;code&gt;Count&lt;/code&gt; reads it from context when its own &lt;code&gt;count&lt;/code&gt; prop is zero (the default). This means the badge doesn't need to know anything explicit, it just reads the group state.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// In Group:&lt;/span&gt;
&lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;overflow_count&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;total&lt;/span&gt;&lt;span class="nf"&gt;.saturating_sub&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;max&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="n"&gt;ctx_provider&lt;/span&gt;&lt;span class="nf"&gt;.provide&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;GroupContext&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;overflow_count&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;..&lt;/span&gt; &lt;span class="p"&gt;});&lt;/span&gt;

&lt;span class="c1"&gt;// In Count:&lt;/span&gt;
&lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;effective_count&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;count&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;ctx_overflow&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;else&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;count&lt;/span&gt; &lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="c1"&gt;// Renders: "+{effective_count}"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;One source of truth.&lt;/p&gt;
&lt;h2&gt;
  
  
  Framework Parity
&lt;/h2&gt;

&lt;p&gt;All three frameworks ship the same API surface:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Feature&lt;/th&gt;
&lt;th&gt;Yew&lt;/th&gt;
&lt;th&gt;Dioxus&lt;/th&gt;
&lt;th&gt;Leptos&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Avatar&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Image&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Fallback&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Group&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;Count&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;total&lt;/code&gt; + &lt;code&gt;max&lt;/code&gt; overflow&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Context propagation&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;delay_ms&lt;/code&gt; on fallback&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Image RS integration&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;td&gt;✅&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The Dioxus and Leptos implementation uses &lt;code&gt;use_context_provider&lt;/code&gt; / &lt;code&gt;use_context&lt;/code&gt; idioms native to each framework, but the behavior is identical. If you've used it in Yew, you already know how to use it in Leptos.&lt;/p&gt;
&lt;h2&gt;
  
  
  Soft Refresh &amp;amp; The Browser Cache Fix
&lt;/h2&gt;

&lt;p&gt;Here's one that caught us off guard. In Yew, images rendered via &lt;code&gt;Image&lt;/code&gt; would sometimes fail to appear after a soft page refresh. Hard refresh? Fine. Soft? Gone.&lt;/p&gt;

&lt;p&gt;The culprit: when a browser serves an image from cache, the &lt;code&gt;load&lt;/code&gt; event fires &lt;em&gt;before&lt;/em&gt; Yew has had a chance to attach the listener. The effect sees a "loading" state, the image is already done, and the component never flips to "loaded".&lt;/p&gt;

&lt;p&gt;The fix was straightforward once we knew what to look for. We inject a &lt;code&gt;node_ref&lt;/code&gt; into the underlying &lt;code&gt;&amp;lt;img&amp;gt;&lt;/code&gt; element and check &lt;code&gt;img.complete&lt;/code&gt; on mount:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="nf"&gt;use_effect_with&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;props&lt;/span&gt;&lt;span class="py"&gt;.src&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="k"&gt;move&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt;&lt;span class="n"&gt;src&lt;/span&gt;&lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;src&lt;/span&gt;&lt;span class="nf"&gt;.is_empty&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;let&lt;/span&gt; &lt;span class="n"&gt;already_loaded&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;node_ref&lt;/span&gt;
            &lt;span class="py"&gt;.cast&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="nn"&gt;web_sys&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;HtmlImageElement&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
            &lt;span class="nf"&gt;.map&lt;/span&gt;&lt;span class="p"&gt;(|&lt;/span&gt;&lt;span class="n"&gt;img&lt;/span&gt;&lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="n"&gt;img&lt;/span&gt;&lt;span class="nf"&gt;.complete&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
            &lt;span class="nf"&gt;.unwrap_or&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;false&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;

        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;already_loaded&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="n"&gt;status&lt;/span&gt;&lt;span class="nf"&gt;.set&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nn"&gt;ImageLoadingStatus&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Loaded&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;else&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="n"&gt;status&lt;/span&gt;&lt;span class="nf"&gt;.set&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nn"&gt;ImageLoadingStatus&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Loading&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="p"&gt;||&lt;/span&gt; &lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;This required adding &lt;code&gt;web-sys&lt;/code&gt; with the &lt;code&gt;HtmlImageElement&lt;/code&gt; feature to the &lt;code&gt;yew&lt;/code&gt; feature gate in &lt;code&gt;Cargo.toml&lt;/code&gt;. A small addition, but it closes a genuinely annoying browser quirk.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4wnh8htpimmv6vyqvz8x.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4wnh8htpimmv6vyqvz8x.jpeg" alt="it works on my machine" width="554" height="554"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Dioxus and Leptos did not have this issue, their reactive systems handle DOM updates differently and don't suffer from this ordering problem.&lt;/p&gt;
&lt;h2&gt;
  
  
  Colors, Variants, Sizes
&lt;/h2&gt;

&lt;p&gt;Everything inherits downward through context. Set defaults at the group level, override them per-avatar if needed.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight rust"&gt;&lt;code&gt;&lt;span class="c1"&gt;// Colors&lt;/span&gt;
&lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nb"&gt;Default&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Accent&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Success&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Warning&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Danger&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Color&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;Custom&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"..."&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="c1"&gt;// Variants&lt;/span&gt;
&lt;span class="nn"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nb"&gt;Default&lt;/span&gt;  &lt;span class="c1"&gt;// solid fill&lt;/span&gt;
&lt;span class="nn"&gt;Variant&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Soft&lt;/span&gt;     &lt;span class="c1"&gt;// muted, lower-contrast&lt;/span&gt;

&lt;span class="c1"&gt;// Sizes&lt;/span&gt;
&lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Xs&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Sm&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Md&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Lg&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Xl&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="n"&gt;Xxl&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; &lt;span class="nn"&gt;Size&lt;/span&gt;&lt;span class="p"&gt;::&lt;/span&gt;&lt;span class="nf"&gt;Custom&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"..."&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;&lt;code&gt;Color::Custom("...")&lt;/code&gt; and &lt;code&gt;Size::Custom("...")&lt;/code&gt; accept raw CSS strings, so if your design system uses &lt;code&gt;hsl(270 60% 50%)&lt;/code&gt; or &lt;code&gt;3.5rem&lt;/code&gt;, those work too.&lt;/p&gt;
&lt;h2&gt;
  
  
  Quick Setup
&lt;/h2&gt;


&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Yew&lt;/span&gt;
cargo add avatar &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;yew

&lt;span class="c"&gt;# Dioxus&lt;/span&gt;
cargo add avatar &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;dio

&lt;span class="c"&gt;# Leptos&lt;/span&gt;
cargo add avatar &lt;span class="nt"&gt;--features&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;lep
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;That's it. The styling is computed inline from the prop values.&lt;/p&gt;
&lt;h2&gt;
  
  
  Accessibility
&lt;/h2&gt;

&lt;p&gt;Every component exposes its ARIA props explicitly:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;Avatar&lt;/code&gt; renders &lt;code&gt;role="img"&lt;/code&gt; with a required &lt;code&gt;aria_label&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;Image&lt;/code&gt; manages &lt;code&gt;aria-hidden&lt;/code&gt; based on loading state.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;Fallback&lt;/code&gt; is hidden from assistive tech once the image loads.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;Group&lt;/code&gt; gets an &lt;code&gt;aria_label&lt;/code&gt; for the whole group.&lt;/li&gt;
&lt;li&gt;
&lt;code&gt;Count&lt;/code&gt; gets its own &lt;code&gt;aria_label&lt;/code&gt; (defaults to &lt;code&gt;"Additional members"&lt;/code&gt;).&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Screen readers get a consistent, clear picture regardless of whether images loaded or not.&lt;/p&gt;
&lt;h2&gt;
  
  
  What We Didn't Do
&lt;/h2&gt;

&lt;p&gt;No auto-injection of count badges. No magic child-slicing that differs between frameworks. No runtime diffing of the children list to figure out how many to show. These patterns break in different ways across Yew, Dioxus, and Leptos, and they make the component harder to reason about.&lt;/p&gt;

&lt;p&gt;Instead: &lt;strong&gt;explicit &lt;code&gt;total&lt;/code&gt; and &lt;code&gt;max&lt;/code&gt; props&lt;/strong&gt;, &lt;strong&gt;explicit &lt;code&gt;Count&lt;/code&gt; placement&lt;/strong&gt;, &lt;strong&gt;one context object&lt;/strong&gt; that everything reads from. It's a little more to type. It's a lot easier to debug.&lt;/p&gt;
&lt;h2&gt;
  
  
  Final Thoughts
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Avatar RS&lt;/strong&gt; is exactly what it says on the tin: a production-ready avatar component for WASM apps.&lt;/p&gt;

&lt;p&gt;It's backed by Image RS, which means you get all the image loading sophistication without reinventing it. The overflow logic is explicit and predictable. Framework parity is real, not aspirational.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://avatar-rs.netlify.app" rel="noopener noreferrer"&gt;&lt;br&gt;
&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fqcspj4eqdqxf6dp022kl.png" alt="Try It Out" width="215" height="66"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwl06pc60hq9ugm11p8vp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwl06pc60hq9ugm11p8vp.png" alt="Try It" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;


&lt;div class="ltag-github-readme-tag"&gt;
  &lt;div class="readme-overview"&gt;
    &lt;h2&gt;
      &lt;img src="https://assets.dev.to/assets/github-logo-5a155e1f9a670af7944dd5e12375bc76ed542ea80224905ecaf878b9157cdefc.svg" alt="GitHub logo"&gt;
      &lt;a href="https://github.com/opensass" rel="noopener noreferrer"&gt;
        opensass
      &lt;/a&gt; / &lt;a href="https://github.com/opensass/avatar" rel="noopener noreferrer"&gt;
        avatar
      &lt;/a&gt;
    &lt;/h2&gt;
    &lt;h3&gt;
      👦 A highly customizable avatar component for WASM frameworks (Powered by Image RS).
    &lt;/h3&gt;
  &lt;/div&gt;
  &lt;div class="ltag-github-body"&gt;
    
&lt;div id="readme" class="md"&gt;&lt;div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h1 class="heading-element"&gt;👦 Avatar&lt;/h1&gt;
&lt;/div&gt;

&lt;p&gt;&lt;a href="https://crates.io/crates/avatar" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/b957c3c6a2262900494b96f7916a83d6656f3919f2cf36b10633636335a44eee/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f762f617661746172" alt="Crates.io"&gt;&lt;/a&gt;
&lt;a href="https://crates.io/crates/avatar" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/6d1e440630631da77476b3de471b081414c7ae04ef3b3fc8171ed2d67f14e7f5/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f642f617661746172" alt="Crates.io Downloads"&gt;&lt;/a&gt;
&lt;a rel="noopener noreferrer nofollow" href="https://camo.githubusercontent.com/10a004fc9a4e7b7c49f5eb1cf322f5834de29fe78588b6fd894bbfe8d80a12a7/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f6c2f617661746172"&gt;&lt;img src="https://camo.githubusercontent.com/10a004fc9a4e7b7c49f5eb1cf322f5834de29fe78588b6fd894bbfe8d80a12a7/68747470733a2f2f696d672e736869656c64732e696f2f6372617465732f6c2f617661746172" alt="Crates.io License"&gt;&lt;/a&gt;
&lt;a href="https://www.rust-lang.org/" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/44b045d4da6c2fd8024c8c66a350a4c8bb9c17faf50009f34dbe64c530de2454/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d616465253230776974682d527573742d3166343235662e7376673f6c6f676f3d72757374266c6f676f436f6c6f723d7768697465" alt="made-with-rust"&gt;&lt;/a&gt;
&lt;a href="https://www.rust-lang.org" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/31c82dd347f4da3b0ee4fb00bdbab1450d962c202a7f1d46feeb52cb06c634fb/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f527573742d312e38392532422d626c75652e737667" alt="Rust"&gt;&lt;/a&gt;
&lt;a href="https://github.com/opensass" rel="noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/5ca62441414bacaa54c6c6e5b68e46c76305947b6bf498c4949fc71c1b4b10dd/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f4d61696e7461696e65642533462d7965732d677265656e2e737667" alt="Maintenance"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a href="https://discord.gg/b5JbvHW5nv" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/1de0ff4ce5ecb14813fe0a4ae22bfb7ab081d2255bde28b216e2d3dc454524d9/68747470733a2f2f646362616467652e6c696d65732e70696e6b2f6170692f7365727665722f62354a62764857356e76" alt="Open SASS Discord"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;a rel="noopener noreferrer nofollow" href="https://raw.githubusercontent.com/opensass/avatar/refs/heads/main/assets/logo.png"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fraw.githubusercontent.com%2Fopensass%2Favatar%2Frefs%2Fheads%2Fmain%2Fassets%2Flogo.png" alt="logo"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;/div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🎬 Demo&lt;/h2&gt;
&lt;/div&gt;
&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Framework&lt;/th&gt;
&lt;th&gt;Live Demo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Yew&lt;/td&gt;
&lt;td&gt;&lt;a href="https://avatar-rs.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dioxus&lt;/td&gt;
&lt;td&gt;&lt;a href="https://avatar-dio.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Leptos&lt;/td&gt;
&lt;td&gt;&lt;a href="https://avatar-lep.netlify.app" rel="nofollow noopener noreferrer"&gt;&lt;img src="https://camo.githubusercontent.com/a2765425215b2af5774668447ff125324caed6bfe2bd4fc6ee74bbbe158c8046/68747470733a2f2f6170692e6e65746c6966792e636f6d2f6170692f76312f6261646765732f62323133313332612d643862362d343934622d386135662d3732393036383261316139352f6465706c6f792d737461747573" alt="Netlify Status"&gt;&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;📜 Intro&lt;/h2&gt;

&lt;/div&gt;
&lt;p&gt;A highly customizable, accessible avatar component for WASM frameworks: Yew, Dioxus, and Leptos.
Supports image loading with automatic fallback content, multiple sizes, color themes, and full WCAG compliance.&lt;/p&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🤔 Why Avatar?&lt;/h2&gt;

&lt;/div&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;🎨 Fully Customizable&lt;/strong&gt;: Control every attribute, class, style, size, color, variant, ARIA labels and more.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;🖼️ Smart Image Loading&lt;/strong&gt;: Tracks &lt;code&gt;idle → loading → loaded/error&lt;/code&gt; status with context. Fallback is shown until the image is ready.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;⏱ Delay Support&lt;/strong&gt;: Prevent flash-of-fallback on fast connections with &lt;code&gt;delay_ms&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;♿ Accessible by Default&lt;/strong&gt;: &lt;code&gt;role="img"&lt;/code&gt;, &lt;code&gt;aria-label&lt;/code&gt;, &lt;code&gt;aria-hidden&lt;/code&gt; wired up automatically.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;🧩 Framework Agnostic&lt;/strong&gt;: Same API semantics across Yew, Dioxus, and Leptos.&lt;/li&gt;
&lt;/ol&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;Y Yew Usage&lt;/h2&gt;

&lt;/div&gt;

&lt;p&gt;Refer to &lt;a href="https://github.com/opensass/avatar/blob/main/YEW.md" rel="noopener noreferrer"&gt;our guide&lt;/a&gt; to integrate this component into your Yew app.&lt;/p&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🧬 Dioxus Usage&lt;/h2&gt;

&lt;/div&gt;

&lt;p&gt;Refer to &lt;a href="https://github.com/opensass/avatar/blob/main/DIOXUS.md" rel="noopener noreferrer"&gt;our guide&lt;/a&gt; to integrate this component into your Dioxus app.&lt;/p&gt;
&lt;div class="markdown-heading"&gt;
&lt;h2 class="heading-element"&gt;🌱 Leptos&lt;/h2&gt;…&lt;/div&gt;&lt;/div&gt;
  &lt;/div&gt;
  &lt;div class="gh-btn-container"&gt;&lt;a class="gh-btn" href="https://github.com/opensass/avatar" rel="noopener noreferrer"&gt;View on GitHub&lt;/a&gt;&lt;/div&gt;
&lt;/div&gt;


&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;We are Open SASS, babe!&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;We're working tirelessly on making Rust web development extremely easy for everyone.&lt;/p&gt;

&lt;p&gt;If you made it this far, it would be nice if you could &lt;a href="https://discord.gg/b5JbvHW5nv" rel="noopener noreferrer"&gt;join us on Discord&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Till next time 👋!&lt;/p&gt;
&lt;/blockquote&gt;

</description>
      <category>rust</category>
      <category>css</category>
      <category>typescript</category>
      <category>tutorial</category>
    </item>
  </channel>
</rss>
