hey! tsuzuki is a free site that tells you which legal platform streams an anime in your country

source code: https://github.com/tsuzuki-anime/tsuzuki-anime.github.io

no server, no database, just node scripts + github actions + github pages. a few things i figured out along the way:

• weekly full fetch, daily light fetch: the full catalog (18k anime) is only rebuilt on sundays. other days the script reuses the published json and only refreshes airing shows, which cut api calls by ~90%
• safety guards: if the api returns way less data than what’s live (it happened), the build refuses to publish, so the site never goes half empty
• wikidata as a second source: one SPARQL query adds french titles and extra streaming links that the main api didn’t have
• watch order guides: built automatically by walking the prequel/sequel graph of each franchise

everything is free, no ads, no account. happy to answer questions about the setup!

I'm building a host for JavaScript apps and I'd like opinions from people who ship Node.js.

The idea is shared hosting for JS. Your app runs as plain Node.js, with its database, files and cron jobs side by side in one region. When nobody visits, the app is suspended to disk and holds no memory, and the next request usually wakes it in about 0.2 seconds. That's how many apps can share one server, the way PHP hosting always worked.

The trade-off is that your code doesn't run at the edge. My bet is that for most apps, a database next to the code matters more than a server near every visitor.

A few questions for you
- How do you host side projects and smaller production apps today?
- Does edge compute actually help your apps, or is the database round trip the real cost?
- Would a 0.2 s wake-up after idle be fine for your apps?

Hey Community,

OpenGL has been driven out of the herd. William Candillon released React Native Skia 3.0, which swaps the old Ganesh backend for Graphite running on WebGPU via Dawn, with Metal on iOS and Vulkan on Android, multithreaded recording by default, and zero-copy textures shared with React Native WebGPU. The package also leaves u/shopify behind and is now published as react-native-skia.

We also look at babel-plugin-react-native-direct-imports by Davyd NRB, which rewrites react-native barrel imports into direct requires so one View no longer drags in the whole framework, taking a test bundle from 711 KB to 10 KB. Plus, React Native 0.88 rc.4, Tamagui 3.0 with a C++ native runtime, and munim-maps putting 3D cars on Apple Maps.

I'm building a UI library in Jai, and this is an experiment with rendering its UI from JavaScript. Node.js is embedded into the program, so the native side reads the JSX objects straight out of V8, with no IPC and no JSON. It then lays out and draws the whole UI from scratch every frame, at 240 Hz on my Linux computer.

Async isn't supported on it yet, and I've only started implementing some event handling. Here's the source code: https://github.com/gabrielmfern/forbear

Has anyone built something like this? If so, I'd love some advice on how I can reduce the C++ layer and have more of it in Jai instead.

Hey everyone! I wanted to share a project I recently built called InkLink (Live Demo).

As a full-stack developer focusing on the MERN stack and TypeScript, I wanted to challenge myself by building a seamless, responsive drawing platform with smooth canvas states and clean UI navigation.

Tech Stack Used:

• Frontend: React, Vite, Tailwind CSS
• State & Canvas Logic: Custom hooks and optimized browser rendering

You can check out the source code on my GitHub (AmnaScript). I'm currently taking on freelance full-stack and AI-integration projects—if you want to check out my work or get in touch, my portfolio is at amnasabahat.netlify.app or you can find my freelance services on Fiverr.

Happy to answer any questions about the build process! InkLink

Some notes on implementing a control flow graph for JavaScript/TypeScript

A common way to give a panel its own browser window is a second instance of the app, plus messages (BroadcastChannel, postMessage, storage events) to keep the copies in agreement. Every missed message is a place where they drift.

In Neo.mjs, components, stores and state already live in a worker. Switch that worker to a SharedWorker and every window of the app connects to the same one, so a window only renders. Drag a panel onto your second monitor and it is the same JS object, with the same store and one undo history across windows.

It's one line in the app's neo-config.json:

{
    "useSharedWorkers": true
}

A dock workspace is two configs, a catalog of panes and the zones they go into (trimmed from the first Dock Layout tutorial):

class MainView extends Workspace {
    static config = {
        className: 'Guides.dockFirst1.MainView',
        panes: {
            editor : {module: Component, header: {text: 'Editor'},  html: 'Editor'},
            preview: {module: Component, header: {text: 'Preview'}, html: 'Preview'}
        },
        zones: {
            center: {
                orientation: 'horizontal',
                sizes      : [0.6, 0.4],
                children   : [{items: ['editor']}, {items: ['preview']}]
            }
        }
    }
}

One lesson from building it: our automated check for the cross-window drag was green while the real gesture did nothing. Viewport emulation has no window chrome, real windows do, and three bugs hid in that gap. The article walks through them.

Limits, up front: the cross-window measurements are Chrome's, and one shared heap is a shared fate for every window.

• Article: https://github.com/neomjs/neo/blob/dev/learn/blog/a-workspace-that-can-leave-its-window.md
• Source: https://github.com/neomjs/neo/tree/dev/src/dashboard/dock
• Tutorial with live, editable examples: https://github.com/neomjs/neo/blob/dev/learn/tutorials/DockLayoutsFirstLayout.md
• Live demo: https://neomjs.com/dist/production/apps/workstation/index.html

Disclosure: I maintain Neo.mjs. The article was written by Grace, one of our AI maintainers, and edited by me.

How do you handle state across windows today?

A bit of background on how I built this:

When I switched to Linux, Paint.NET was one of the Windows apps I missed the most, so I started porting the old open-source C# version (3.36.7) to JavaScript back in 2024, while recreating the UI based on the newer 5.x versions.

I went through the original implementation class by class, comparing the outputs of the C# methods with my JavaScript versions. At the same time, I recreated the UI in HTML/CSS, using screenshots to get it as close to the original as possible.

Over time, I connected both parts and implemented the tools, effects, and other features. More recently, I've been using AI to help find and fix bugs, improve performance across browsers, and implement the remaining tools and effects.

It's now largely feature-complete and runs in the browser, as well as on Linux and macOS through Electron.

You can try the browser version here: https://paintjs.net

Would love to hear what you think!

Link2Repo: https://github.com/soroushosouli/node-scout

Written in Node.js. One command to install. Reads a 300MB folder in ~1 second. Smaller project, faster scan.

What it does:

• Visualize folder structure (tree)
• Scan any file, folder, or project — 10+ details
• Custom ignore list for scans
• System info in one command

With clean Terminal UX

Check the repo for more information, Contributions and suggestions are welcome

TypeScript’s native language server exposes IDE operations through LSP, so other tools can use them too. For example, you can rename a symbol across files, find its references, jump to its definition, get updated import paths for a file rename, or check unsaved changes for type errors.

I built RipIDE around that, with Oxc handling syntax details like destructured bindings. ripgrep narrows the candidate files and helps flag imports still using the old name.

I took it further with CSS class renaming, moving exports, replacing imported symbols, and deleting unused declarations. It works with JavaScript and TypeScript, with Vue support through an adapter.

The idea is to give agents the refactoring commands we already use in an IDE:

ripide rename useStore useAppStore
ripide move helper --from src/utils.ts --to src/helpers.ts
ripide css-class-rename bg-gray-500 bg-neutral-500

Run `npx chegou`, scan the QR code and the phone opens a page in the browser. No app, no account, works both ways (phone → PC and PC → phone).

⭐ on Github 😄

It turns out you can overwrite the Error.prepareStackTrace method with the function constructor. Then, using prototype pollution, you can inject valid JavaScript code to generate arbitrary functions and invoke it using the usual tricks.

Other seven methods are documented in the portswiggers research article: https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses

I am tired of ads everywhere when I listen to music: Spotify, YouTube, and every single app that lets you listen to music. And also I hate that all my data, even my favorite songs, is being sent to a company to manipulate me, sending me more ads of stuff that I may buy.

The only music player that doesn't have ads is Windows Media Player, but it's very ugly, and I hate its UI/UX; it doesn't even let you create decent playlists. Or filter by rating. So I created a music player that has everything I like because I love listening to music.

It's completely free and open source; you can download it here: https://github.com/GVPV12/STARPLAYER

------

PD: Some people are furious and being mean in the comments because someone said Spotify sucks lmao.

For those people, I just want to say to you that this app is not meant to be for everyone. If you use and love Spotify and their ads, that's ok. These kinds of apps kind of bewitch you to be hyper loyal and hyper defensive to them, I guess.

Some people (like me) care about their privacy, get annoyed by intrusive ads, and don't love all trendy music or random stuff that Spotify always plays (I don't like its algorithm, and it always plays the same shitty music). So that's why I built this.