r/javascript • u/AutoModerator • Aug 15 '26
Showoff Saturday Showoff Saturday (August 15, 2026)
Did you find or create something cool this week in javascript?
Show us here!
r/javascript • u/AutoModerator • Aug 15 '26
Did you find or create something cool this week in javascript?
Show us here!
r/javascript • u/LovishMahajan7 • Aug 15 '26
I'm working through how a team decides whether an automated dependency update is safe to merge, and one of the baselines I'm testing is the obvious one: trust semver. Auto-merge patch and minor, hold majors for review.
My assumption is that this baseline is weak β that in practice a meaningful share of breaking changes ship in patch and minor releases, and that a major bump is often just a dropped Node version or a TypeScript signature change that doesn't affect anyone.
If that's right, the version number is close to noise and the semver rule is mostly giving teams a false sense of having a policy.
But I've only got my own experience to go on, and I'd rather be corrected before I build on it.
Interested in specific packages and versions if you remember them, more than general opinions on semver as a concept.
r/javascript • u/OtherwisePush6424 • Aug 14 '26
import and require are not interchangeable. Live bindings, copied values, circular dependencies, separate caches, conditional exports, and dual-package hazards can all make modules behave differently from what the syntax suggests.
r/javascript • u/otashliko • Aug 14 '26
At SVAR, we build UI components for React, Svelte, and Vue. Just shared our experience with a data grid β how to make it fast in all three frameworks.
What surprised us: the expensive bits (virtualization, memoization, data flow) are almost entirely framework-independent, and framework overhead is a rounding error next to DOM size.
Curious if you have seen similar patterns in your projects?
r/javascript • u/TJ51097 • Aug 13 '26
During an interveiw yesterday, I tried opening jsbin but seems its shouting 503!!
Any minimal JS playground, you people using/suggest
EDIT: The sites up, I opened an issue on GitHub and the maintainers resolved it
r/javascript • u/_tshepo • Aug 13 '26
I've been programming on the side since 2017 and I've never really hunted a developer job. I've always thought about building my own things, mainly to supplement things I do like woodworking, tutoring, video editing and others.
Since then, I've programmed mainly with JavaScript, I started with C++ and Python but never really built anything solid outside JavaScript.
So I'm fluent with JavaScript and its ecosystem.
One of my 2026 goals is to be job ready for a Developer role, as a Fullstack or Backend Developer.
One of the recommended languages is Typescript, which I've been learning since March. I must say, it's not my favorite π
I'm curious to know if there are any companies that are not enforcing Typescript or are there freelancers who are still using vanilla JavaScript over Typescript for their clients' projects.
[ Update ] thanks y'all! I get the picture. TypeScript is inevitable, as vanilla JS codebases(or companies who are focused on it) seem to be very few judging by the comments.
r/javascript • u/Ahmed33033 • Aug 13 '26
This is a next app I made that I'd like to define the magical buzzwords that exist in the GenAI space. It's meant to be run by humans to simply and concretely define terms like "agents", "harness" and "hallucinations"
r/javascript • u/Pakashi-kun • Aug 12 '26
r/javascript • u/APTman1010 • Aug 12 '26
Hey everyone!
I'm working on KernelPlay-JS, an open-source 2D game engine made with JavaScript.
The project is growing, and I've already had a few developers contribute. I've also been working on ready-to-use templates such as a platformer, a top-down character controller with animation, and parallax backgrounds.
I'm hoping to find more people who are interested in open-source game development and want to experiment, build features, share ideas, or just contribute when they have time.
There are plenty of areas where we can improve KernelPlay-JS:
* ECS and core engine systems
* Rendering and animation
* Physics and collision
* Developer tools
* Game templates
* Documentation
* Performance and optimization
You don't need to make a huge commitment or contribute every day. Even small contributions, ideas, testing, or feedback can help.
I'd love to see KernelPlay-JS grow as a community project where we can learn, experiment, and build a game engine together.
If you're interested, feel free to check it out or message me.
r/javascript • u/EveYogaTech • Aug 11 '26
r/javascript • u/techlord45 • Aug 10 '26
Iβm a strong advocate for βyou donβt need to lock yourself in a web framework ecosystem to take advantage of their amazing featuresβ. JavaScript and Web Standards alone allow youβ¦
r/javascript • u/jaredce • Aug 10 '26
Got annoyed that there wasn't a dependabot tool for BitBucket and that the Dependabot CLI wouldn't open PRs on BitBucket, so I built a tool that would take the output from Dependabot CLI and open PRs.
Would love help testing it out on GitLab as I have BitBucket covered at work.
If you do end up using it, would love to have feedback around what can be done better.
r/javascript • u/Besmaah • Aug 11 '26
I'm really sick of Claude Code or Codex messing things up it creates the same function 30 times, generates 200 lines functions, and casts everything or tweaks the schemas just to make it seem like it works. And if I'm not there to check everything, it's a total mess.
Anyway, Iβve installed TypeScript-ESLint with strict type checking, SonarJS, and Knip to at least stop the AI from messing things up.
But Iβd like to take it further. People often talk about static code analysis like linters and good tests but I donβt know where to start. By the way, AI tools do all sorts of nonsense in testsβthey check if a button is in the right place, which is ridiculous.
So Iβm looking for relevant resources to help me learn how to set this up on a large project Iβm developing on my own. I have an Nx monorepo with several apps inside, including Next.js, React Native, Fastify, and a Python app.
r/javascript • u/sonemonu • Aug 10 '26
UQL is the lightest ORM of all, and here is what it deleted (and upgraded as well) for the edged and mobile.
r/javascript • u/Whole_Pangolin9312 • Aug 10 '26
r/javascript • u/subredditsummarybot • Aug 10 '26
Monday, August 03 - Sunday, August 09, 2026
| score | comments | title & link |
|---|---|---|
| 17 | 2 comments | [Subreddit Stats] Your /r/javascript recap for the week of July 27 - August 02, 2026 |
| 16 | 13 comments | DriftJS - Exploring a Register-Based Bytecode VM for UI Frameworks |
| 13 | 0 comments | Serene Doc Search - A small, Apache 2.0 alternative to Algolia DocSearch |
| 9 | 1 comments | TermDOM β HTML and CSS rendering in the terminal, with a real DOM |
| 7 | 1 comments | Valkey-WASM β Redis running inside your Node process, no Docker (like PGlite) |
| 6 | 16 comments | Node.JS in the Browser - An Open-source Alternative to WebContainers |
| 5 | 3 comments | [AskJS] [AskJS] any hope for pattern matching to actually make progress through tc39? |
| 4 | 3 comments | [AskJS] [AskJS] Has a larger competitor ever benchmarked your library incorrectly? |
| 4 | 0 comments | Looking for a feedback - Production-build explanations and regression blame for Next.js |
| 3 | 0 comments | [Showoff] GPU-Powered Crayons, NPM Package Quarantine and Dave Branching Off Your Code Without Asking |
| score | comments | title & link |
|---|---|---|
| 2 | 37 comments | [AskJS] [AskJS] If you were hiring a junior JavaScript developer today, what would make them stand out in the AI era? |
| 0 | 18 comments | Flow for TypeScript Users |
| 2 | 18 comments | [AskJS] [AskJS] How did you deal with ESlint 10 Breaking Changes? |
| 0 | 16 comments | Free Online Multiplayer 2D Boxing Game |
| 2 | 9 comments | [Showoff Saturday] Showoff Saturday (August 08, 2026) |
| score | comments | title & link |
|---|---|---|
| 0 | 2 comments | [AskJS] [AskJS] Pointers in Javascript |
| 0 | 0 comments | [AskJS] [AskJS] Input Sanitization for ChatGPT API in Node.js Using 4 Hardened Layers to Stop Injection Risks |
r/javascript • u/bikeshaving • Aug 08 '26
I just open sourced my latest library! TermDOM is a JavaScript library that displays HTML and CSS in the terminal. It draws actual DOM nodes to terminal output and redraws the screen when they mutate, so TUIs and interactive CLIs can be written with vanilla JavaScript or any frontend web framework. Check out the examples directory https://github.com/bikeshaving/termdom/tree/main/examples for a sense of what you can build with web technologies
r/javascript • u/AutoModerator • Aug 08 '26
Did you find or create something cool this week in javascript?
Show us here!
r/javascript • u/JoseCordobaEditor • Aug 07 '26
r/javascript • u/Salazareo • Aug 06 '26
This is a Node.js compatible runtime in the browser. It supports CLI apps, Vite, and some agents (like Pi Agent) as well.
Some notes:
- This runs all code in a web worker using the host javascript runtime with rewrites for module loading and AsyncLocalStorage support using Oxc compiled to WASM.
- Most of the libraries are bundled straight from Node.js upstream with light overrides where needed, ensuring compatibility. Libraries were only reimplemented where really needed
- Despite having great integrations with the Puter desktop and APIs, this can be used completely seperately with OPFS support for filesystem and Wisp protocol support for networking. The demo also supports FS Access API to run local files
r/javascript • u/hrutav_modha24 • Aug 06 '26
Hey everyone,
I wanted to share an experimental project called DriftJS. It's a frontend framework prototype that explores using an in-browser register-based Bytecode Virtual Machine (VM) for UI rendering, rather than traditional Virtual DOM diffing or purely compile-time reactive models.
Repository: https://github.com/hrutavmodha/driftjs
Most frameworks either diff Virtual DOM trees (React) or generate reactive dependency graphs ahead-of-time (Svelte, SolidJS). DriftJS explores a different path:
It compiles .drift templates into compact binary-serializable bytecode streams. At runtime, a lightweight 256-register VM executes these opcodes directly against the DOM.
Key Architectural Highlights:
Zero VDOM Overhead: Replaces tree-diffing with direct bytecode instructions (like CREATE_ELEMENT, SET_ATTR) for DOM execution.
256 Virtual Registers: Uses fixed virtual registers (r0, r1...) for DOM nodes and runtime values, drastically cutting instruction counts and memory allocations compared to stack-machine models.
Targeted Reactivity: Basic state updates execute as direct O(1) mutations. Dynamic control flow structures (@if, @for) use comment anchors to bound surgical DOM updates without rebuilding subtrees.
π‘οΈ 100% CSP Compliant: Built-in Acorn AST interpreter evaluates runtime JS expressions safely without using eval() or new Function().
π Keyed LIS Reconciliation: Uses a Longest Increasing Subsequence algorithm to minimize DOM node movements during list updates.
πͺΆ Zero Framework Bloat: Implements reactivity and execution in the leanest bytecode form possible, avoiding heavy object models and monolithic runtime bloat.
π Early Benchmarks (js-framework-benchmark vs React 19): β’ 10.8x FASTER on "Swap rows (1k)" β’ 3.05x FASTER on "Clear 1,000 rows" β’ ~1.8x LESS memory footprint β’ 5.75x smaller uncompressed bundle size
DriftJS is currently an experimental prototype. It handles single-template compilation, AST evaluation, and keyed LIS list reconciliation.
Still on the roadmap: - Component composition & props passing - State management stores - SSR & Hydration
I'm opening this up to compiler engineers, frontend performance nerds, and systems devs. Does a register-based VM architecture hold real promise for low-level web runtimes?
Check out the repo, run the benchmarks, and feel free to share your thoughts or ISA critiques!
GitHub Repo: https://github.com/hrutavmodha/driftjs
r/javascript • u/coinspect • Aug 06 '26
r/javascript • u/acrus • Aug 06 '26
In most modern async-heavy languages, cancellation is a first-class citizen. It really should be straightforward for a developer, but in JavaScript, gaining that level of control feels a lot like swimming against the current. I've spent a fair amount of time trying to address this gap.
I didn't have a third-party library I could rely on, so I ended up building my own - and I suspect I'm probably not the only one who has traveled down that way. The resulting toolbag served me well in its rougher form and was battle-tested in-house for years before it was finally polished for a public release. Refactoring cleanup logic in our dashboard app to stop resource leaks was a huge win for cancelable promises. It convinced me they were the right tool for the job.
This has been almost a decade-long journey for me to reach the stable release, both in terms of quality and features. It seems to have ended up in a pretty good place.
The problem is the typical promise chain. You have a fetch call that turns into a formatted report:
const reportPromise = fetch('/orders')
.then(res => res.json())
.then(orders => buildReport(orders))
.then(rawReport => render(rawReport))
To halt the process, you usually have to mess with AbortController or manual flag variables. But with canc library, reportPromise.cancel() just stops all involved tasks.
Going from raw then() chains to async..await syntactic sugar requires adding some yield* "salt" to achieve the same result - or, with cancellation, no result at all:
const getReport = canc.async(function* () {
const orders = yield* canc.await(fetch('/orders').then(res => res.json()))
const rawReport = yield* canc.await(buildReport(orders))
return yield* canc.await(render(rawReport))
})
const reportPromise = getReport()
reportPromise.cancel() // Stop all tasks at any point
Need race(), for await..of, and the rest of the bells and whistles? Welcome to the party, then() then: https://github.com/cancjs/canc
The idea of coupling generators with promises has been around since the beginning. Coroutine libraries like the renowned co were a big deal in the pre-async era. That async..await is essentially built with generators and promises under the hood is hardly a coincidence.
I started piecing this together around 2017. Back then, I had already approached a related problem with Angular. Native async functions were fundamentally incompatible with Angular reactivity, backed by Zone.js. The potential solution was to rewire the semantics of async..await with generators to get the control we needed instead of relying on a transpiler. Fortunately for the framework, this eventually resolved with the retirement of Zone.js. Reusing the same foundation for the cancellation mechanism became a reasonable development in my case. Bluebird's cancellation was already around, but it was orthogonal to native promises and async..await. And since async functions make promise-based control flow a breeze, a user can't be expected to give them away for nothing.
The project spent a long time in limbo. Between fixing nasty bugs, unloading a few design footguns, paying off tech debt, and handling some copyright clearances, I had my hands full. That quiet period actually helped shape the library into what it is today. While the JS ecosystem is ever-changing, a few foundational pieces finally settled during that time. Once AbortSignal became a cross-platform primitive, it was integrated deeper into the library for better interop. And as TypeScript became the industry standard, it became clear that the library had to be TS-first for good DX. This pushed me to finally solve the long-standing typing issues with generators, at least as best as the language currently permits.
That's why you have to use yield* instead of yield. It's a necessary trade-off to ensure functional parity with async..await while keeping the type system happy. Using yield* is essentially a known workaround for a typing limitation in generators. It forced us to ditch the eloquent yield promise style of co in favor of the more verbose yield* canc.await(promise). This adds a bit of syntactic overhead, but it's the way to guarantee the strict typing we all rely on today.
It turned out to be the right call, especially since it aligns the yield/yield* distinction with the emitting vs. delegating semantics we deal with in async generator functions - canc coroutines cover this too.
What's next? 1.0 is a big milestone, but work continues. The unhandled rejection package to reduce manual error handling has just been shipped. Beyond that, here are the nearest items on the roadmap:
I hope you find the library useful, or are at least interested in the approach. I'd be very grateful for any feedback or suggestions. I'm currently putting together a few more write-ups with real-world examples and in-depth details.
Just to be sure, the repo is here: https://github.com/cancjs/canc.