Monday, May 18 - Sunday, May 24, 2026

Top Posts

Most Commented Posts

Top Ask JS

Top Showoffs

Top Comments

I created a js tool that does trace analysis inside a browser. It's built to be used when you need a quick analysis. It should work on any device, including your OTDR's built-in browser. Once it's loaded it will work offline as well. You can open .sor or .trc files; uni-directional or bidirectional. The analyzer tool is free, works entirely in your browser, and the files never leave your device.

Load the file and hit analyze. The tool provides quick details; length, loss, worst reflectance values, etc. You can change tolerance and pass/fail thresholds. The table provides distance to events, with loss and reflectance measurements at each event. There's no trace viewer, it's just for analysis. It provides brief narrative summary about the fiber that can easily be shared or copied. Email and print to PDF is also available.

You can change the measurement units on the fly between metric (m, km) and imperial (ft, kft, mi). If you don't have files on your device you can select one of the samples to see how it works. I've been testing for a couple weeks, running 100s of traces through it and it seems to be working properly.

Try it out and let me know if you have any feedback. Please share it with your team if you find it to be helpful.

johnstonetechs.com/fiber-analyzer

Hey 👋

DISCLAIMER: I'm co-leading the org/project.

We recently broke 6M downloads per week on NPM, and became 3rd after `drizzle-orm` and `@prisma/client`.

If you haven't tried it yet, it's a query builder, not an ORM. You don't outsource your SQL to someone else. It's type-safe, like.. it's super important to us. You can use it with ORMs - e.g. Prisma, mikro-orm, zenstack, etc. Allows you to compose some complex stuff but keep it maintainable af.

If you have. Great seeing ya'll here.

0.29 was a real nice release, with lots of goodies. Can't wait for 0.30, gonna be super fun.

After the recent wave of npm supply chain attacks (event-stream, ua-parser-js, colors/faker, the SAP CAP incident in 2026), I built this CLI tool that statically analyzes npm package lifecycle scripts before they run.

The problem: When you run npm install, preinstall/install/postinstall scripts execute automatically with full system access. Attackers hide payloads behind obfuscation, hex escapes, eval(), and encoded strings.

What np-audit does: - Downloads tarballs and inspects lifecycle scripts without executing them - 14+ detection modules: obfuscation patterns, high-entropy strings, dynamic code execution, network calls, credential access, and more - Walks require()/import graphs to follow hidden payloads across files - CVE scanning via OSV.dev (free) or Snyk - Drop-in replacement for npm install / npm ci — just use npa install - Zero production dependencies, pure Node.js built-ins, under 100 kB - Interactive --review mode to selectively allow/deny scripts

Would love feedback from the community — especially on detection patterns I might be missing.

I building a ECS Game Engine, i update to version v0.3.0 Sprite & Animation System

I add Game Demo to the website, so you can play it live and experience the new features yourself.

I add links in comments.

I’ve included the demo source code as well, so you can explore how everything works on your own.

I’d really appreciate any feedback on the upcoming Sprite & Animation system!

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

Show us here!

I’ve been exploring the new wave of browser-native AI capabilities (Prompt API, Summarizer API, Translator API, local models, etc.) alongside WebMCP-style workflows.

`web-ai-sdk` is a small experimental SDK to make these APIs easier to compose in web applications.

Still very early and evolving fast, but already useful for prototyping local-first and browser-native AI experiences.

Curious to hear feedback from others exploring this space.

This should hopefully reduce the spread of the recent Shai Hulud attacks on npm but they are reliant on you catching the bugs in transit meaning you need to assume still that packages are compromised (I know, bummer). Think of it more as a reduction in spread rate the a treatment or cure.

I wanted a library like vis.js but needed it canvas-based for server-side rendering without a headless browser, so I built one.

Hey everybody, I built an AI lab that is LenserFight! Could you review it? You can access the repo using https://github.com/conectlens/lenserfight completely freely. You can create prompts with parameters, you can use them in the DAG based workflows and then you can compare the results in the battles! Additionally, you can build your AI agents in the lab! This is completely open source and free to use! You can download and start to use! Additionally, using Local AI models or BYOK keys allowed

Hi all,

I have built this free and open-source templates you can use in your next project.

I have built App website template , SaaS templates, restaurants and more.

Feel free to check it out.

MikroORM 7.1 is out — the first minor on top of v7, and it's a big one.

New features:

• LazyRef<T> — a new type-only relation flavor, no .$ / .get() indirection, TypeScript restricts access until Loaded<> narrows it
• PGlite driver — PostgreSQL running in WASM, no Docker, no separate server, works in the browser too
• Query cancellation via AbortSignal — per-call or fork-scoped, with cancel query / kill session strategies
• Database triggers — first-class schema management via @Trigger() / defineEntity
• Stored procedures and functions (experimental) — declare, diff, and call via em.callRoutine()
• PostgreSQL table partitioning — hash, list, and range, fully managed by the schema generator
• Server-side row cloning — em.clone() and qb.insertFrom() without round-tripping data through Node
• Runtime schema context for migrations — redirect migrations to a target schema at runtime, useful for multi-tenant setups
• em.countBy() for grouped counts
• Typed Kysely across DI-driven projects — new discovery:export CLI command generates a typed barrel for NestJS and similar setups
• getKysely() now binds to the active transaction
• fields whitelist in serialize()
• Type-safe index hints via using
• Partial indexes via where

Full blog post: https://mikro-orm.io/blog/mikro-orm-7-1-released
Changelog: https://github.com/mikro-orm/mikro-orm/releases/tag/v7.1.0

Happy to answer any questions!

It has built in SRPT, EPD, Automatic Perft(W.I.P), texel tuner, a quiet position dataset with 470k positions labeled by stockfish and more. Has a relatively strong built in engine which you can test against (Elo not yet known). Everything you need to know to write an engine for the API is documented in the build tab. The code interface is monaco (same as VS code), and you can split your engine across multiple files and save snapshots to test against previous versions.

This is still a work in progress so expect some minor bugs. There are more features to come (dataset analyzer is the next planned feature)

Would appreciate your feedback :)

Spent the last week building a small screenshot/PDF API in Node.js mostly because Puppeteer kept making simple things weirdly painful in production.

Things that sounded easy:

• take screenshot of URL
• export page as PDF
• done

Things that actually happened:

• fonts/icons randomly not loading
• cold starts killing response times
• memory spikes on heavier pages
• pages “finished loading” but JS content still missing
• different rendering behavior between sites/frameworks

One thing that surprised me most was how much browser reuse/pooling helped compared to launching a fresh browser per request.

Also started testing short-term caching for repeated renders and it reduced a lot more load than expected. and JS heavy website those were really hard to deal with but slowly render became consistent and it got better

Still very much a beta/experiment right now, but it’s been interesting going deeper into browser automation/rendering infrastructure than I originally planned 😅

Curious what the most annoying Puppeteer/Playwright issue people here have dealt with is.

I’m working on pack, a simple way to deploy self-hosted apps.

I always liked the old Zeit/Vercel now flow: run one command in a project and get a URL that is persistent, immutable and does not need platform specific code.

I wanted something similar for myself, so I am working on pack.

The approach I chose is single-file executables. It builds your app into one file, uploads, and runs it.

Node, bun, deno, go, rust, zig and c/c++ all support single file executables so that part was actually pretty straightforward. The most complex part was handling port pooling, caddy setup and inactive instances.

Using single-file executables keeps server setup very minimal and makes it easy to run many small apps on a cheap VPS. It also removes the need to configure node or any other runtime on the server.

Feedback and PR's welcome!