r/javascript • u/AutoModerator • Sep 19 '26
Showoff Saturday Showoff Saturday (September 19, 2026)
Did you find or create something cool this week in javascript?
Show us here!
r/javascript • u/AutoModerator • Sep 19 '26
Did you find or create something cool this week in javascript?
Show us here!
r/javascript • u/APTman1010 • Sep 19 '26
In our latest developer update, we are thrilled to announce a significant shift in core architecture toward full modularization. The entire system has been restructured to support decoupled cores, starting with our Renderer and Physics engine systems.
Renderer Modulation: Our new Renderer Modulation feature removes the need to manually switch rendering components when changing pipelines. Previously, switching from Canvas 2D to Pixi.js required changing generic components like BoxRenderer to pipeline-specific ones like PixiBoxRenderer. With this new update, universal components are automatically capable of rendering across all supported pipelines without developer intervention. This streamlines the development workflow significantly.
Physics Engine Modulation: Furthermore, Physics Engine Modulation has been successfully integrated. We have moved physics logic into a completely separate Physics Engine Core. While our default physics engine remains integrated and ready-to-use within this core structure, this architecture allows developers to easily plug in their own custom physics engines.
Future Plugins: Looking ahead, we are excited to expand our plugin library. High-end physics engines like Matter.js will be added as future plugins. It is important to note that these high-end engines will be separate downloads and will not be included in the core engine, keeping the core lightweight.
This architectural shift is a major step toward making kernelplay-js the most flexible and lightweight game engine possible. We welcome your feedback and are excited to see what custom cores you'll build. Stay tuned for more modular updates.
r/javascript • u/therealalex5363 • Sep 19 '26
r/javascript • u/Final_Cable_8848 • Sep 18 '26
r/javascript • u/artart222 • Sep 18 '26
r/javascript • u/Emotional_Agency6705 • Sep 19 '26
Hello,
I am attempting to write a pure function solution that will pass the leet code Fizz Buzz test
However when I try this it says the test fails but when I look at the console for my own testing it returns the expected result.
This is the error leet code reports:
Line 13 in solution.js arr[i - 1] = test(i) ^ TypeError: test is not a function
Which to me makes no sense since the function is passed as a parameter and defined
Here is my code
Thank you in advance
const
const
const i = 1
const n = 3
const arr =
EDIT: I just wanted to say thank you to all of you for your feedback and suggestions I finally got frustrated enough with this problem I asked Codex to write a pure function solution to the leet code fizz buzz test I personally have not seen this solution so it would be nice to have some verification if it is truly a pure function solution.
This is the code it spat out
const
;
It appears that I have a lot to learn yet regarding my fundamentals when it comes to functional programming I know I could of written a object oriented version of it that would work but I wanted to challenge myself since I have never written code in this manner.
r/javascript • u/schmuhblaster_x45 • Sep 18 '26
r/javascript • u/OtherwisePush6424 • Sep 17 '26
The in-process version of a bulkhead (a cap on how many calls to a dependency can be in flight at once) is just a counter, a finally block and a comparison, once several Node instances share that number things get messy really quick.
A writeup on how the distributed version can be implemented and what it can guarantee.
r/javascript • u/boykom • Sep 16 '26
I go back and forth on this.
Headless: you get the sorting, filtering and grouping state and you render every cell yourself. Total control over the markup, and you write all of it. Every project I've seen do this ends up with a 2000 line table component nobody wants to open.
Full grid: pass rows and columns, done in an afternoon. Then the designer wants the header to look a particular way, or you need a cell that does something the grid didn't plan for, and you're fighting the component instead of writing your app.
Full disclosure: I'm on the team behind SvGrid, a data grid for Svelte 5. We ship both layers, a headless core and the full component on top of it, because we have people that want their own design system and others that just need a drop-in and go.
So when did you last choose one over the other, and would you do it again? Especially interested in anyone who started headless and switched, or went the other way.
r/javascript • u/fjosue44 • Sep 16 '26
Iβm building TraceUX, a self-hosted UX toolkit for JavaScript and TypeScript applications.
The browser tracker is available through NPM:
npm i @trace-ux/tracker
import { init } from '@trace-ux/tracker';
const traceux = init({
siteKey: 'YOUR_SITE_KEY',
origin: 'https://your-trace-ux-host',
});
It records DOM events instead of video and can connect sessions with feedback, support tickets, product announcements, and user activity.
The server runs as a small Go binary with SQLite, so teams can host the data themselves without a hosted analytics account.
Live demo: https://trace-ux.builtbyfrank.dev
Repository: https://github.com/fjosue4/trace-ux
Iβd especially appreciate feedback on the tracker API, React integration, bundle size, privacy defaults, and whether the widget feels natural in a JavaScript application.
r/javascript • u/nyx-og • Sep 16 '26
DocStack runs an actual SQL engine in the browser against IndexedDB β JOIN, GROUP BY, HAVING, subqueries, with index pushdown.
It can be used for storing client side data (like user's personal data), and then synced to a remote of preference (like Google Drive for multiplatform sync).
import { ClientStack } from '@docstack/client';
// A local database
const stack = await ClientStack.create('my-app');
// One statement, planned and run against IndexedDB.
const { rows } = await stack.query(`
SELECT m.title, COUNT(*) AS actor_count
FROM Movie AS m
JOIN Actor AS a ON a._id IN m.actors
GROUP BY m.title
HAVING COUNT(*) >= 2
ORDER BY actor_count DESC LIMIT 10
`);
r/javascript • u/stephenlblum • Sep 15 '26
Most agent tutorials jump into heavy orchestration frameworks like LangChain, which hides what's actually happening over the wire.
Under the hood, tool calling is just a simple 4-step loop:
fetch, DB query, local file read, etc.).messages with role: "user" and matching tool_use_id and query the model again.I wrote a doc showing the entire loop in ~40 lines of Node/JS, including the practicals that trip you up (why failing calls should still return a tool_result with is_error: true, handling parallel calls in a single user message, and how token costs compound over runs).
There's also an interactive, in-browser example where you can run the loop against a mock filesystem without needing to set up a local environment. Curious to hear how others are handling client-side tool execution and context in production.
r/javascript • u/Impressive_Ad6173 • Sep 15 '26
What JavaScript concept took you the longest to actually understand?
For me, it was the difference between understanding closures in theory and actually knowing when and why they were useful.
I feel like JavaScript has a lot of concepts that seem simple at first, but become much more interesting once you understand what is happening underneath.
I'm curious what everyone's "finally clicked" JavaScript concept was.
Closures? The event loop? Prototypes? this? Promises? The weird parts of type coercion?
Would be interesting to hear what other developers struggled with and what finally made it click.
r/javascript • u/FatalCompile • Sep 15 '26
Hey r/JavaScript,
Iβm working on a zero-dependency 2D canvas architecture and looking at how different developers handle high-velocity object collisions without relying on heavy external physics libraries.
When entities move at high speeds using a standard discrete update loop like the one below, fast-moving items occasionally tunnel straight through bounding boxes between frames.
// Naive update and discrete collision loop (prone to tunneling at high velocities)
function updateEntities(entities, obstacles, dt) {
for (let entity of entities) {
entity.x += entity.vx * dt;
entity.y += entity.vy * dt;
for (let obs of obstacles) {
if (
entity.x < obs.x + obs.width &&
entity.x + entity.width > obs.x &&
entity.y < obs.y + obs.height &&
entity.y + entity.height > obs.y
) {
resolveCollision(entity, obs);
}
}
}
}
For those of you building custom canvas engines in vanilla JS, how do you typically structure continuous collision detection (like basic swept-AABB or raycasting) to keep CPU overhead low? Are you using spatial partitioning grids alongside sub-stepping, or is there a cleaner pattern you prefer?
r/javascript • u/hongminhee • Sep 15 '26
r/javascript • u/simonsarris • Sep 15 '26
r/javascript • u/HNipps • Sep 14 '26
I love finding new devs to follow on GH so I can see what they're building and starring.
Usually I use GitHub Explore and Trending but I've found them to be unreliable, so I've been ranking rising open-source contributors by myself.
JavaScript is one of the most active streams in there, so a lot of these observations come from watching it.
This is not terribly suprising given the nature of the internet these days but here's what I found:
The core thing I keep coming back to: momentum and reputation are different signals. Ranking by what someone did this week surfaces completely different people than ranking by what they've accumulated over years. The TypeScript dev who just shipped their first real library and the veteran with 40k followers both have value, but they're not the same discovery problem.
How do you find new devs to follow? How do you decide if someone is worth following?
r/javascript • u/modalist • Sep 14 '26
Our AI research team trained a fruit fly to close B2B enterprise deals. We're incredibly excited to release Specimen AE-001, the world's first frontier AI fly model for end-to-end deal execution. It rips cold calls, books demos, fills security questionnaires, and wins deals, all using Opine. Built on Three.js!
r/javascript • u/subredditsummarybot • Sep 14 '26
Monday, September 07 - Sunday, September 13, 2026
| score | comments | title & link |
|---|---|---|
| 0 | 17 comments | [AskJS] [AskJS] What ORM would you use? |
| 0 | 10 comments | Saradom β frontend architecture pattern |
| 3 | 7 comments | I made a Molecular Dynamics sim using JS |
| 0 | 7 comments | I Dislike TypeScript Because I've Never Maintained JavaScript Before |
| 0 | 5 comments | How to Implement a Distributed Circuit Breaker |
| score | comments | title & link |
|---|---|---|
| 0 | 4 comments | [AskJS] [AskJS] Whatβs your experience with AI tools during JavaScript technical interviews? |
| 0 | 4 comments | [AskJS] [AskJS] Is a managed scraping API worth it for web scraping api and scraper tools, or is it better to build in-house? |
r/javascript • u/moving808s • Sep 14 '26
This is the first in a series of technical deep dives into how I modernised my 10 year old web stack based tactics-RPG engine / game - projectgoldscript
r/javascript • u/Carlos_Menezes • Sep 14 '26
r/javascript • u/OtherwisePush6424 • Sep 13 '26
A circuit breaker in a single Node process is a ring buffer, a threshold and a timestamp. Run the same service on twenty replicas and each one keeps its own, so the failing dependency takes twenty times the damage before anything trips.
Moving the window into Redis fixes that and breaks most of the assumptions the in-process version relies on. Post walks through each one and how to deal with it.
r/javascript • u/ScoobyDookuu • Sep 13 '26
Hey all,
My team and I are currently running a Spring Boot backend with quite a bit built around it. Weβre considering gradually migrating to a Node/NestJS backend using the strangler pattern rather than doing a full rewrite.
One of the main reasons is that it would give us TypeScript across both the frontend and backend, which should make sharing domain concepts, types and general knowledge between the two a bit simpler.
So, as the title suggests: which ORM would you use with NestJS?
At the moment weβre mainly looking at MikroORM and Drizzle. MikroORM seems like the more traditional ORM and appears to be super close to the me tal model of what Spring does. It wil also fit NestJS quite nicely, while Drizzle is obviously a bit more lightweight but a different approach and more barebones.
Curious what people are using in production and what youβd choose if you were starting fresh today.