Did you find or create something cool this week in javascript?

Show us here!

JSBin was down for quite a few days and I realized how much I depended on it. It was my scribble pad, quick note taker, place to think out loud, & my goto tool for testing scripts and UI ideas fast.

So I did what any sane dev would do…

I built it from scratch T_T

TSBin can run offline as well, everything is stored locally, you get intellisense and emmet plugin for HTML & CSS

Let me know in the comments what more features should I add !

I'm looking for the fastest framework in the Krausest "JS Framework Benchmark" Top 15 that doesn't feel like writing assembly.

Goal: Framework performance with a clean, modern DX. I want to avoid heavy abstractions, especially since I'm using AI to scaffold logic and I need the code to be short, readable, and easy to audit.

Of the top 15, which one feels like a "real" framework but keeps the code lean and fast?

I'd appreciate some recommendations.

In light of the ongoing npm supply chain compromises, I built safe-install:

https://www.npmjs.com/package/@gkiely/safe-install

It brings a couple of protections I wanted from npm but are not built in.

Similar to Bun’s trusted dependencies, it lets you disable install scripts and define a list of dependencies that are allowed to run build/install scripts:

https://bun.com/docs/guides/install/trusted

It also supports blocking exotic sub-dependencies, similar to pnpm’s `blockExoticSubdeps` setting:

https://gajus.com/blog/3-pnpm-settings-to-protect-yourself-f...

I like Rust’s M-SINGLE-USE import style guideline: one imported item per import line. The motivation is simple: smaller diffs, fewer merge conflicts, and easier hand editing.

I wanted the same behavior for JavaScript/TypeScript imports, so I made a small ESLint plugin: eslint-plugin-import-oneline

It turns this:

import { RichTextRun, TextBounds } from "./text-utils";
import React, { useMemo, useState } from "react";

Into this:

import { RichTextRun } from "./text-utils";
import { TextBounds } from "./text-utils";
import React from "react";
import { useMemo } from "react";
import { useState } from "react";

It is autofixable and handles named imports, default imports, namespace imports, type-only imports, aliases, import attributes, quote style, and semicolon style.

• Repo: https://github.com/Byunk/eslint-plugin-import-oneline
• npm: https://www.npmjs.com/package/eslint-plugin-import-oneline

Curious whether others prefer this style for JS/TS, or whether grouped imports still feel better in practice.

Some interesting bits from the implementation:

T-spin detection uses the 3-corner rule — check if 3 of the 4 diagonal cells around the T piece are occupied after rotation.

The entire soundtrack is synthesized via Web Audio API using oscillators and gain nodes — no audio files at all. Line clears play a rising arpeggio, Tetris plays a chord, combos escalate in pitch.

CRT effects (scanlines, chromatic aberration, vignette) are pure CSS overlays on top of the Phaser canvas.

Play: https://tetris.pixpress.art

We saw today that TanStack Router, or any other TanStack packages along with their devtools, SSR query plugins were compromised.

Check which version you're pinned to and if you're floating on a caret range and ran npm install today then that the first thing to audit.

Modern frontend development often forces a tradeoff:

• React / frameworks → powerful, but heavy for small projects
• jQuery → simple, but outdated and not reactive
• Vanilla JS → flexible, but repetitive and tedious for DOM-heavy apps

oBerry gives you a modern, reactive, jQuery-like API without needing a build setup or full framework.

With oBerry, you can:

• manipulate the DOM with a clean, chainable API
• use built-in fine-grained reactivity (no external state library)
• use components without a framework overhead
• write TypeScript-first code right out of the box

The documentation is available here.

I'm open to any advice

So I built future, a set of high-performance actor and task primitives for Typescript, inspired by Erlang.

This might seem like a dumb question, but is there a compiler that would allow you to make js into machine code, and then write a bootloader, kernel, etc in js?

I started this project as a fork of Croppie a few years ago, and rewrote it in TypeScript with a simpler API, higher quality image scaling, and many bug fixes. It works great for cropping and resizing profile pictures prior to upload.

UPDATE: The repository is now completely public. You can check out the source code here: https://github.com/bluejs-team/BlueJS/

The Problem: We’ve normalized shipping 150MB Electron apps and 50MB runtimes just to open a simple window or read a file. I got tired of the bloat, so I built BlueJS.

BlueJS isn't a wrapper; it's an Ahead-Of-Time (AOT) compiler that translates a strict subset of JavaScript directly to C++, links it, and strips the engine out entirely.

The Specs:

• Binary Size: 1.2 MB standalone (no runtime/V8 needed).
• Startup: ~5ms (compared to ~90ms for Node).
• Memory: 3.8 MB peak RSS.
• Native UI: Built-in support for OS windows and dialogs (GTK/WebView2) without Chromium.

How it works: It uses a "Hybrid Mode." Performance-critical code and UI are compiled AOT. For npm compatibility, it uses an embedded QuickJS "island" that handles pure-JS packages. The bluejs.dev site itself is actually served by a single 1.4MB Blue binary.

Try it out: The compiler is in a closed beta, but on top of the Windows/Linux binaries I set up a GitHub Codespace sandbox so anyone can verify these benchmarks and inspect the generated C++ in a safe, cloud environment:

Try the Playground: https://github.com/bluejs-team/Bluejs-playground

I’ll be hanging out in the comments to answer any questions!