mrkeyoor.comAsk

chenglou/handwiredtested 15 Nov 2026commit 257856e

handwired review

Our Handwired sandbox installation succeeded in 13 seconds and its test step passed in 615 seconds, making the recorded developer setup a credible starting point for experiments.

  • Safety failed
  • Tests pass
13 sto install
  • 49 packages
Dev Toolsevaluationupdated 15 Nov 2026
+7stars / 7d

Handwired is Cheng Lou's experimental project for expressing program logic as a neural network with hand-written weights. Developers manually rewrite logic with its builder API, creating a numeric program whose continuous values can participate in gradient-based learning.

Verdict

Our Handwired sandbox installation succeeded in 13 seconds and its test step passed in 615 seconds, making the recorded developer setup a credible starting point for experiments. Use it if you want gradients through logic you understand and can rewrite by hand. Skip it if you need automatic JavaScript conversion, a stable library interface or ordinary backpropagation that learns hard thresholds.

Handwired infographic: express program logic as a neural network, plus its uses, our test result, pitfalls and who it suits
Tested 15 November 2026: the source install took 13 s.

We ran it

Lab card: what happened when we ran handwired
Lab card from our sandbox run
Screenshot of handwired (chenglou.me/handwired)
chenglou.me/handwired
Install✓ · 13s49 packages · 145 MB
Buildn/ano build script
Tests✓ · 615sran, no count parsed
Repo1542 files~277,076 lines of source · 31.2 MB · 1 CI workflows · tests dir

Answers from our run

Does handwired build from source?

Dependencies installed in 13 seconds (49 packages), and the project has no separate build step. We cloned commit 257856e into a clean Debian container with 3 CPUs and no project-specific setup.

Do handwired's tests pass?

Yes. The project's own test command exited successfully in 615 seconds, although its output did not expose an individual test count.

Who should not use handwired?

Teams expecting automatic conversion of existing JavaScript: the FAQ says developers write builder code by hand.

What are the alternatives to handwired?

TensorFlow.js, PennyLane. Our Handwired sandbox installation succeeded in 13 seconds and its test step passed in 615 seconds, making the recorded developer setup a credible starting point for experiments.

Setup4/5Our source checkout installed in 13 s with 49 dependencies, but we did not run a README task.Editor’s note: The recorded installation and test steps passed, but the Compose runner stopped before an end-to-end application task. No numeric editorial rating is assigned.
Docs4/5The README has an install command and usage examples in code; we did not run its quickstart ourselves.Editor’s note: The README and official tutorial explain the builder and host model. The independent wiki adds setup guidance; complete documentation coverage has not been assessed.
Community3/5Last push on 2026-10-17, 2,156 stars and maintainers answered or closed 0 of the 3 most-discussed issues we sampled.Editor’s note: The sampled X posts contain concrete experiments. Three supplied issues show an experimental method, a reaction and a feature proposal, without enough support history to rate responsiveness.
Maturity1/5No tagged GitHub release, repository created 2026-10-15 and its test suite passed in our sandbox.Editor’s note: The author calls Handwired a toy project, and the wiki documents no stable API promise. Our repository checks do not measure production reliability or commercial adoption.

How we score

Discussed on

  1. hnShow HN: Turn regular JavaScript into a neural net46 points
  2. hnTurn your regular JavaScript code into a neural net9 points
  3. hnTurn your regular JavaScript code into a neural net6 points
  4. hnHandwired: Turn your regular JavaScript code into a neural net5 points
  5. hnHandwired3 points

Who it’s for

JavaScript developers exploring gradients through existing, readable logic.
Researchers connecting a hand-written calculation to a learned model, as in the reported handwriting calculator.
Developers willing to start from a small template and maintain a JavaScript behavior reference.

Who it’s NOT for

Teams expecting automatic conversion of existing JavaScript: the FAQ says developers write builder code by hand.
Applications requiring a stable npm API: the independent setup guide describes a private package and commit-pinned Git imports.
Developers expecting ordinary backpropagation to learn hard breakpoints: issue #1 reports zero gradients for threshold constants through exact emitCompare decisions.

Setup reality

Our November 15, 2026 sandbox run at commit 257856e installed successfully in 13 seconds, recording 49 dependencies and 145 MB on disk. Tests succeeded in 615 seconds. The build was skipped because there was no build script or target. The configured sandbox had 3 CPUs, 8 GB RAM and image label lab-node:22.

The README's local path uses Bun and bun start. The independent wiki documents a browser CPU runtime and a pinned Git dependency for bundler integration. Its examples don't begin with model-provider credentials or a hosted inference service.

Integration requires manual builder code and attention to numerical declarations. The image label doesn't identify actual runtime or OS versions. A separate hands-on runner failed its Compose-file prerequisite; its conflicting deployment summary cannot support a completed application run.

Short answer: use Handwired to experiment with logic you can rewrite

In our run, Handwired installed in 13 seconds and its test step passed in 615 seconds at commit 257856e. Use it if you're a JavaScript developer exploring how hand-written logic can participate in gradient-based learning. Skip it if you need automatic conversion of an existing application or a stable library interface for a production dependency.

Handwired is Cheng Lou's experimental project for expressing program logic as a neural network with hand-written weights. The interesting choice is what happens after the logic works: you can expose selected numbers to training, or connect the program to a learned model. The README describes both possibilities. Our recommendation is to start with a small formula whose outputs you already understand, rather than translating an application before you've learned the execution model.

What people use handwired for

Community builders have used Handwired for a handwriting calculator and a voice instrument, while Cheng Lou's demos cover desktop interactions and learned layouts. These examples give a clearer reason to try it than the phrase “JavaScript neural network” alone.

Who built it What they report doing Why it matters to a developer
X user anshuc Combined calculator logic and handwriting recognition, then used gradient descent backward through both to find inputs producing a chosen answer. Calculator report Existing application logic can participate in the same optimization problem as a learned recognizer.
X user henloitsjoyce Built Meloform, fitting frequency components of short voice recordings with Handwired backpropagation and synthesizing them at different pitches. Meloform report A small fitting problem can produce an audible result without starting from a general-purpose language model.
Cheng Lou, described by the independent wiki Built Mini OS with window focus, stacking, dragging, resizing, springs and a gallery in one numeric program without training. Gallery description The program representation can express stateful interaction, beyond a single arithmetic expression.
Cheng Lou, described by the independent wiki Built Learned gallery, training photo-layout values with Adam while the user edits a sketch. Learned gallery description Layout becomes a fitting task with examples supplied through an interface.

The calculator is the clearest explanation of the appeal. In anshuc's account, the recognizer and calculator run together, and a desired answer becomes the starting point for searching backward. Handwired supplies a way to carry gradients through the calculator's logic. That is a more specific reason to rewrite code than simply wanting an application to look like a network.

Meloform takes the same idea somewhere different: fit the components of a recorded sound, then reconstruct that sound at other pitches. Both are attributed community reports, with the original posts linked above. They demonstrate what people chose to build; the supplied records contain no commercial outcome for either project.

What happened when we ran it

Our November 15, 2026 sandbox run installed commit 257856e in 13 seconds and completed the test step successfully in 615 seconds. The configured environment had 3 CPUs, 8 GB of RAM and image label lab-node:22.

Recorded check Result What to take from it
Dependency installation Succeeded in 13 seconds The recorded Node/Bun installation path completed.
Dependencies 49 recorded, 145 MB on disk This is the dependency footprint from our sandbox.
Build Skipped: no build script or target There is no successful build result to claim.
Tests Succeeded in 615 seconds The recorded test command passed; the supplied block gives no test count.
Checkout 1,542 files, approximately 277,076 source lines, 31.2 MB These are repository scan figures, not the shipped browser bundle.
Repository signals One CI workflow file, a tests directory, no Dockerfile detected These describe the checkout, not CI reliability.

Installation was the short part. The test command occupied the sandbox much longer, which matters if you're repeatedly changing a circuit and checking the repository. Keep the 615-second result attached to this commit and environment. The image name alone gives neither the actual runtime version nor the operating-system version; those require the raw toolchain logs.

A separate hands-on runner stopped at its safety check because it required a Compose file. Its record says none of compose.yaml, compose.yml, docker-compose.yaml or docker-compose.yml existed, and labels the checkout “unsafe repo” under that rule. That is a runner prerequisite failure, not evidence of malicious code or a broken runtime.

The run summary says it deployed with the project's own Docker Compose on November 15 and bound ports to 127.0.0.1. That generic summary conflicts with the specific failed safety step, so it cannot support a deployment claim. The successful installation and test results above come from the separate sandbox measurement block. Our measurement setup separates repository checks from application tasks; how we test explains that distinction.

Where people get stuck: exact decisions give thresholds zero gradient

The author of issue #1 reports that ordinary backpropagation leaves a threshold constant unchanged through an exact emitCompare decision. This is the most useful failure report for anyone hoping to learn a responsive breakpoint.

Imagine giving the program examples of the layout you want at different viewport widths. Margin and gap values can move with a gradient, while the breakpoint controlling a hard branch stays where it started. In issue #1, the author describes precisely that behavior and proposes a training-time method based on Gaussian-smoothed loss and evaluating individual decision flips. The issue record is open, with no comments. It contains a proposed workaround, not a maintainer-confirmed fix.

Symptom in the supplied sources What the source recommends Status and decision
A breakpoint gets zero gradient through emitCompare Issue #1 proposes gradients from smoothed loss and individual decision flips Experimental workaround reported by the issue author.
A distant threshold receives no useful signal with narrow smoothing Begin with wide smoothing and shrink it during training Reported schedule requirement, not an automatic runtime feature.
You expect existing JavaScript source to convert directly The wiki FAQ says to rewrite the logic using the builder API Budget for a manual translation.
You expect a normal npm dependency and stable imports The wiki setup guide uses a commit-pinned Git dependency Treat upgrades as a deliberate code change.

The breakpoint experiment also illustrates a subtle evaluation mistake. The issue author says any breakpoint between neighboring example viewports fits those examples exactly. A fitted layout can therefore match the examples while learning a different breakpoint from the target design. If the boundary itself matters to your application, put examples near that boundary. Matching a few rendered layouts answers a different question from recovering the designer's original constants.

The host still handles browser inputs and DOM writes

The official tutorial keeps a JavaScript host around the numeric program to write inputs, run an evaluation and copy outputs to the DOM. Handwired doesn't remove that integration work. In the toggle tutorial, the builder creates a fixed list of operations over FP32 values. The host fills a source table, evaluates the program, writes next-state values back and updates the page. That division is useful when deciding how much code to translate: start with the calculation or interaction whose gradients you want, and keep its surrounding browser plumbing visible.

The execution model also distinguishes agreement between evaluators from agreement with the JavaScript being replaced. Two execution paths can reproduce each other's values while sharing the same mistake in the translated program. Keep a plain JavaScript reference for the behavior you care about, as the toggle example does. This is particularly valuable when the source logic includes several states or selections that happen to look right in one screenshot.

Bun demos and Git imports are the documented entry points

The README's local route is to clone the repository, install with Bun and run bun start; the independent wiki describes importing TypeScript sources through a pinned Git dependency. For a first look, use Cheng Lou's live demos or the repository's toggle template. For integration, the wiki's getting-started page describes Vite transpiling the runtime's TypeScript sources directly. It also discusses allowing TypeScript import extensions with noEmit. Those instructions describe a bundler-based path, rather than a published npm package with a stable API promise.

The wiki says its own toggle demo runs the official template unmodified. That is a concrete integration report worth more than a generic compatibility badge. Keep the exact commit you choose alongside your own circuit and its reference behavior. The wiki's pinned example revision is an example of dependency control, not a reason to silently replace the revision you're evaluating.

The browser runtime evaluates programs in JavaScript on the CPU, according to the wiki FAQ. Its gallery says the in-page demos need no server. For those examples, a model-provider account is not the entry point; the work is understanding cells, operations and the host loop.

Handwired vs plain JavaScript, learned models and quantum tools

Plain JavaScript is the sensible baseline when you only need the existing program's answers; Handwired becomes relevant when you want its numeric representation or gradients.

Choice Reason to choose it Evidence behind the distinction
Plain JavaScript Keep ordinary application logic when neither gradients nor the demonstrated GPU path are part of the task The README and toggle tutorial use JavaScript behavior as the reference.
Handwired Encode logic you understand, then experiment with trainable values or a connection to a learned model The wiki FAQ recommends starting from readable code and rules you want to preserve.
A conventional learned model Learn behavior when you have plentiful data and no trusted program to encode This is the wiki FAQ's recommended alternative for that situation.
PennyLane Work on quantum algorithms rather than wait for a proposed Handwired quantum target Issue #10 requests such a target; PennyLane's own README describes a quantum software platform.

TensorFlow.js is a concrete alternative for training and deploying machine-learning models in JavaScript. Its README describes building models from scratch and running converted existing TensorFlow models in the browser. Choose it when the job begins with a learned model or model-training API. That is a different starting point from encoding a known program with Handwired's builder.

PennyLane belongs here only because issue #10 explicitly asks for a quantum-circuit target. The supplied thread is an open proposal with no comments. It is evidence of somebody's desired direction, not a feature announcement. Select a quantum project for a quantum workload today.

X user secemp9 calls Handwired a DSL with fixed, neural-inspired gates and contrasts it with fitting input-output behavior or reusable program execution. That criticism is useful for setting expectations. You can value the encoding experiment without treating every approach involving weights as the same kind of machine learning.

What the other reviews get wrong

Handwired requires hand-written builder code, and its exactness claims have numerical contracts. Those qualifications change the reader's workload and belong beside the headline promise. Deduped's overview describes the result as exact and fully differentiable. The wiki FAQ supplies the missing boundary: exact comparisons depend on declared operand ranges, and helpers such as division and square root are approximate with documented error bounds. A reader choosing arithmetic for a real application needs that distinction before deciding to translate it.

The independent wiki's homepage says data can tune constants while rules stay exact. Issue #1 adds the practical qualification: a constant controlling an exact decision can receive zero gradient. Coefficients inside continuous calculations and thresholds selecting branches deserve separate treatment when designing the learning problem.

The supplied YouTube overview titled “Handwired GitHub Overview” describes a compiler taking standard JavaScript control flow. Its transcript presents that explanation without establishing an automatic source-conversion path. The wiki FAQ explicitly says there is no automatic converter. The supplied video record has no channel attribution, so we attribute this description to the titled video rather than inventing a creator name or claiming the creator completed a working deployment.

The name also belongs to keyboards and guitar gear

Cheng Lou's Handwired is the software repository chenglou/handwired; physical handwiring results answer a different question. Searches for “handwired keyboard” and “handwired split keyboard” concern physical keyboard construction. The supplied QMK hand-wiring guide lists switches, diodes, a microcontroller, wire and soldering equipment. If you're deciding between a wired switch matrix and a PCB, use that hardware documentation rather than this neural-programming review.

“Handwired amps,” “handwired deluxe reverb,” “handwired ac15,” “handwired vox ac15,” “handwired ac30” and “handwired tube screamer” are guitar-gear queries, not features or editions of this software. “Handwired vs PCB amps” and “handwired vs PCB” likewise concern hardware construction in the supplied search evidence. The pack includes Fender's amp-construction explainer and Vox amplifier reviews. Naming the repository owner in a search is the quickest way to stay with the software.

Questions people ask

Cheng Lou's Handwired GitHub repository is github.com/chenglou/handwired, and the project is MIT licensed, according to the wiki FAQ.

Where is Cheng Lou's Handwired GitHub repository?

The repository is chenglou/handwired. The wiki FAQ identifies Cheng Lou as its author and explains that handwired.wiki is an independent community resource by En Dash Consulting, without affiliation or endorsement from him.

Can ordinary JavaScript logic become a neural network without training?

Yes, Handwired's weights are constructed by hand rather than learned before the program can run. The README demonstrates expressing a conditional with arithmetic and ReLU. Optional learning is a later experiment with the resulting representation.

Is Handwired an automatic compiler or a manually written DSL?

You manually write builder code that appends operations to a Circuit. The FAQ explicitly rejects automatic conversion of existing JavaScript source. The official tutorial then explains the host and source-table work around that circuit.

What is new about Handwired's hand-written neural networks?

The practical attraction is encoding known program logic into a network whose numbers can participate in learning. The README proposes unfreezing weights and attaching a frozen program to a generic neural net. That explains its intended use without claiming historical priority over other differentiable-programming work.

How do I use Handwired in a Vite or TypeScript project?

The wiki setup guide describes adding a commit-pinned Git dependency and importing runtime TypeScript sources directly. Start with the documented toggle template and its plain JavaScript reference so you can compare the behavior before adapting the program.

Does Handwired need a GPU or WebGPU?

No: the FAQ says the runtime evaluates in JavaScript on the CPU. The JSON search demo uses WebGPU shaders to search 100,000 documents in parallel. The README's millisecond execution statement is the author's report, not our performance measurement.

How can exact decisions be differentiable?

The FAQ says exact decisions are steps with zero slope, while gradients remain useful for continuous quantities such as positions, sizes and coefficients. The official execution model further says backpropagation differentiates intended real arithmetic rather than literal floating-point rounding.

How can I train threshold constants through exact emitCompare decisions?

The author of issue #1 proposes Gaussian-smoothed loss and individual decision flips. Treat that as an experimental training method with its stated smoothing schedule, rather than expecting the ordinary backward pass to learn a hard breakpoint.

Can a Handwired ranking formula learn from clicks while preserving its rules?

The independent wiki's ranking demo trains formula coefficients while holding pinned-result and stock rules fixed. Its shoppers are simulated. It offers an inspectable example of a learning setup, not a report of increased sales from a deployed store.

Could Handwired support a quantum circuit compilation target?

The author of issue #10 proposes exploring one. The supplied record is open with no comments and establishes a request only; it contains no completed implementation or maintainer commitment.

What we have not tested yet

Our successful repository checks stop short of an end-to-end browser evaluation, a security assessment or an independent GPU benchmark. We did not reproduce the calculator, Meloform, learned gallery or ranking outcomes, and the Compose safety failure supplied no application screenshots or known-answer task results.

The supplied issue #1 extract excludes equality decisions, endWithBoolean, emitArgmax trees and index reads from its proposed method. It also says independently computed boundary terms miss cases where two decisions help only when flipped together. We have not tested that method or extended those results to other circuits. The record's final bullet is cut off, so it cannot support a further conclusion about min operations.

Long-running behavior, mobile browser compatibility, training quality on a representative dataset and production support capacity remain untested. The recorded API snapshot on November 15 lists a last push of October 17, 2026; the sampled issues are open and mostly provide requests or reactions. Issue #3 is an enthusiastic reaction, not a defect report with a resolution. The issue #3 record supplies no technical support result. Those facts cannot tell us whether a future production problem will receive a timely response.

There is no independent hardware-specific measurement supporting a universal speed advantage over JavaScript in this evidence set. The unreadable second video transcript and blocked forum page add no usable software result. If you're evaluating Handwired, choose one calculation, keep its ordinary JavaScript reference, and measure the translated version on the browser and hardware you intend to use.

Alternatives

ProjectWhat it isPick it when
TensorFlow.jsA JavaScript library for training and deploying machine-learning models.Choose it when your task begins with training a model or running an existing TensorFlow model in the browser.
PennyLaneAn open-source software platform for quantum computing and quantum machine learning.Choose it for an actual quantum workload; the Handwired quantum target in issue #10 is a proposal.

Sources

  1. Handwired README
  2. Official toggle tutorial
  3. Official execution model
  4. Community FAQ
  5. Threshold-training report
  6. Community experiments
  7. TensorFlow.js README
  8. PennyLane README

More dev tools reviews