Key Takeaways
- Handwired converts ordinary JavaScript code into a neural network structure, so the program's logic becomes a differentiable graph rather than a trained model.
- It requires no training and produces exact outputs that match the original JavaScript program, which is the opposite of how normal neural networks behave.
- Everything is designed to run in a browser without a GPU, so it should work on phones and desktops once it is released.
- No public build, download or official page exists yet; so far Cheng Lou has only shown the project in a short preview announcement.
Quick Facts
| Type | Browser-based JavaScript-to-neural-net compiler |
|---|---|
| Devices | Desktop and mobile browsers, no GPU required |
| Price | Not announced; no public build yet |
| Languages | JavaScript input; interface details unconfirmed |
| Highlight | No training, exact outputs, fully differentiable |
| Learning curve | Easy to try, deeper concepts need ML basics |
| Category | Dev & Web Tools |
| Creator | Cheng Lou |
| Heat | 🔥 1.4M Heat |
| Last updated |
What Handwired Actually Does With Your JavaScript
Handwired is a toy project from Cheng Lou that takes ordinary JavaScript code and turns it into a neural network. The key twist is that nothing is trained: instead of learning weights from data, the tool compiles your program's logic into a network-shaped structure that reproduces the same behavior. Cheng Lou introduced it as a project that converts regular JavaScript into a neural net, with exact outputs matching the JavaScript program and full differentiability.
That combination is unusual. In normal machine learning you collect data, train a model, and accept approximate results. Handwired skips training entirely and promises outputs identical to the source program, so you can compare the JavaScript result and the neural net result side by side and see them agree. The whole thing is meant to run in a browser without a GPU, which keeps it lightweight and accessible.
Because it is described as a toy project, the framing is playful rather than production-oriented. The point is to explore what happens when you treat code as a differentiable graph you can run in a browser tab. It is a fresh angle on the boundary between ordinary programming and neural computation, and that is exactly why developers are paying attention right now.
- No training step
You do not feed it datasets or wait for epochs. The network is derived from your code, so the usual train-and-evaluate loop disappears.
- Exact outputs
The converted network is meant to match the original JavaScript program's results exactly, which makes verification straightforward.
- Fully differentiable
The compiled structure is differentiable, meaning gradients can flow through logic that started life as plain JavaScript.
- Browser and GPU-free
It is designed to run in a browser without a GPU, so phones and laptops should both be able to handle it.
How Code Becomes a Differentiable Network
The core idea is compilation rather than learning. Your JavaScript function is analyzed and rewritten as a graph of operations that behaves like a neural network: values flow through nodes, and each node's operation is differentiable. Because the structure mirrors your original logic, running it produces the same answers your JavaScript would, but now you can also compute gradients through it.
Differentiability is the interesting part. In a conventional program, an if-statement or a loop is just control flow with no meaningful derivative. A differentiable version has to express that logic in a way gradients can pass through, which is why the project is described as fully differentiable rather than merely translated. This is the same broad family of ideas behind differentiable programming, where programs and neural networks become the same kind of object.
Running without a GPU matters for reach. Neural network tooling usually assumes heavy hardware, but Handwired is aimed at the browser, so the computation has to stay small enough for ordinary devices. That constraint shapes what kinds of JavaScript programs make sense to convert, and it is why the creator frames the project as a toy rather than a heavy-duty framework.
- Start with small functions
Simple arithmetic or a short pure function is the easiest way to see the conversion clearly before trying anything longer.
- Compare outputs directly
Run the original JavaScript and the converted network on the same inputs and check that the results match exactly.
- Think in graphs, not statements
Understanding the conversion is easier if you picture your code as a dataflow graph where every edge carries a differentiable value.
- Expect limits on complexity
Browser-only execution without a GPU suggests very large or heavily branching programs may not be practical.
How to Try Handwired and What to Do First
The honest starting point is that there is no public build, download or official page yet. Cheng Lou has only shown Handwired in a short preview announcement, so you cannot install it or paste code into a live demo today. Anything you read about exact menus, supported syntax or performance numbers is unconfirmed until the creator publishes something runnable.
While you wait, you can prepare in ways that will pay off immediately when a build appears. Keep a few small, pure JavaScript functions handy, meaning functions with no side effects that return a value based only on their arguments. Those are the cleanest candidates for conversion because their behavior is easy to compare against a network version.
It also helps to refresh the concepts the project leans on. If you understand what a computational graph is, why gradients need differentiable operations, and how browser JavaScript handles numeric work, you will be able to judge the tool's claims quickly. When an official page does appear, check it for supported syntax, browser requirements and whether mobile support is included, since those details have not been confirmed.
- Prepare pure functions
Collect short functions that take inputs and return outputs with no external state, since these are the easiest to verify against a converted network.
- Watch for the official release
Follow Cheng Lou's own announcements rather than third-party summaries, because availability details change fast for early projects.
- Learn the vocabulary
Terms like differentiable programming, computational graph and gradient will make the preview much easier to interpret.
- Do not trust unverified specs
Until a build exists, treat claims about supported JavaScript features, speed or device support as unconfirmed and check the official site.
Where Handwired Fits Among Neural Network Tools
Handwired is not a replacement for TensorFlow.js, PyTorch or ONNX-based browser runtimes. Those tools train or run models on data, and they are built for real applications. Handwired does something narrower and stranger: it takes code you already wrote and expresses it as a network with exact behavior. That makes it a teaching and exploration tool more than a production framework.
Compared with differentiable programming languages and libraries, Handwired's distinguishing feature is its starting point. Instead of asking you to write your program in a new differentiable language, it takes JavaScript as input and runs in a browser without a GPU. That lowers the barrier considerably for web developers who already know JavaScript but have never touched gradient-based computation.
The limitations follow from the same design. Exact outputs and no training mean it is not useful for prediction or pattern recognition, which is what most people want from a neural network. It is best suited to developers curious about differentiable programming, educators explaining how networks relate to code, and anyone who enjoys small, well-made experiments from respected developers.
- Versus TensorFlow.js
TensorFlow.js trains and runs models on data in the browser; Handwired converts existing code into a network with no training at all.
- Versus differentiable languages
Those require writing in a new language, while Handwired accepts ordinary JavaScript as its input.
- Best-fit audience
Web developers, students and tooling enthusiasts will get the most from it; production ML teams will not.
- Main caveat
With no public build yet, every practical detail still needs to be confirmed on the official site when it launches.
Step-by-Step Guide
Confirm whether a build exists yet
Check Cheng Lou's own announcements and the official site for a runnable version. As of the preview, no public build, download or official page had been published, so this step may simply confirm you need to wait.
Pick a small, pure JavaScript function
Choose a short function with no side effects that returns a value from its arguments. Simple arithmetic, a clamp, or a small formula works well because you can verify the output by hand.
Run the conversion in the browser
Once a build is available, paste or load your function and let Handwired compile it into a network. Because it is designed to run without a GPU, an ordinary laptop or phone browser should be enough.
Compare outputs on identical inputs
Feed the same inputs to your original JavaScript and to the converted network, then check that the results match exactly. This is the project's central claim, so it is the first thing worth testing.
Scale up carefully and note the limits
Gradually try longer functions and watch for slowdowns or unsupported syntax. Browser-only, GPU-free execution implies practical size limits, so record where the tool stops being comfortable.
Frequently Asked Questions
Is Handwired available to try right now?
No. No public build, download or official page has been published yet, and Cheng Lou has only shown the project in a short preview announcement. You cannot paste code into a live demo today. To know when that changes, watch the creator's own announcements and check the official site rather than relying on secondhand summaries.
Does Handwired require training or a GPU?
According to the announcement, it requires no training and runs in a browser without a GPU. Instead of learning weights from data, it compiles your JavaScript into a network that reproduces the program's behavior. That design keeps the computation light enough for ordinary devices, though the exact performance characteristics are unconfirmed until a build is released.
How can the outputs be exact if it is a neural network?
Because the network is derived from your code rather than learned from data. The conversion preserves the program's logic as a differentiable graph, so running it yields the same results as the original JavaScript. That is the opposite of a trained model, which approximates. You can verify the claim by comparing outputs on identical inputs once a build exists.
What does fully differentiable mean here?
It means gradients can flow through the converted structure, so the network version of your code can be used in gradient-based computation. This places Handwired in the differentiable programming family, where programs and networks are treated as the same kind of object. It is the property that makes the project interesting beyond a simple code translation.
What should I do while waiting for a release?
Prepare a few small, pure JavaScript functions that you can convert and verify quickly, and brush up on computational graphs and gradients so the preview makes sense. Follow Cheng Lou's announcements for availability. Treat any specific claims about supported syntax, browsers or mobile support as unconfirmed until the official site says otherwise.
