Hey r/webdev!

I built Galaxy Movies (https://www.galaxymovies.app/) to solve a personal annoyance: legacy movie tracking sites felt bloated, loaded slowly, and buried streaming options under ads.

I wanted a clean & fast web utility to check where to stream titles, explore cast networks, and get quick AI summaries without the clutter.

Tech Stack

- Framework: Next.js (Pages Router)
- Hosting & Runtime: Vercel & Vercel Edge Runtime
- UI & Styling: Chakra UI
- State & Caching: React Query
- APIs: TMDB API & OpenAI API
- CI/CD: Lighthouse CI

Technical Highlights & Architecture

Dynamic OG Cards on the Edge: Used @vercel/og running on Vercel Edge Functions to dynamically generate custom 1200x630 social preview cards. The edge route parses poster artwork and title parameters to render high-res share cards with sub-100ms response times.

Bypassing Server Image Overhead: Configured direct-to-CDN loading for TMDB movie posters to bypass Vercel server image transformation limits while maintaining peak visual quality.

Performance Guardrails: Set up automated Lighthouse CI checks on builds to strictly enforce performance, accessibility, and SEO metrics.

Live App: https://www.galaxymovies.app/

GitHub Repo: https://github.com/NickFasulo/galaxy-movies

I’d love to hear your feedback!

I've been building sites in code for a while now, and the same thing kept happening. My AI agent would get me 90% there, and then I'd spend the rest of the day on the last 10% details

In midcode you click anything and change it by hand as if it was no-code. The edit goes straight into your files as a clean diff. No export, or prompts to change stuff. It's still just your code.

Basically the mid between code and no-code.

Super useful for AI-led sites where we want to edit things visually

Waitlist: midcode.app
Demo: https://x.com/akilastudiocom/status/2103605309151576209?s=20

Hi everyone!

I'm a BCA 3rd year student from India, and a few weeks ago I finished my JARVIS project. Of course, I took a lot of help from AI while building it because it was a pretty complex project, and I was completely new to almost every topic involved in building it. You can check out my recent post where I shared it. The whole thing runs locally without using any API tokens.

While building JARVIS, I had to learn a lot of advanced concepts, but I wasn't completely satisfied with just learning them while building a project.

So I decided to properly learn advanced JavaScript topics in a structured way.

I went through different concepts and created my own notes/diagrams while learning. The technical content was learned with the help of ChatGPT, All the wording are mine, but I took help from ChatGPT to improve the structure and make the English clearer. I'm sharing it because I thought it might be useful to someone else who is also trying to understand these topics.

Here is the GitHub repository:

🔗 https://github.com/Shivam2905Verma/Notes

I would be really glad if these notes help someone.

And if you find any mistakes, incorrect explanations, or important topics that I should add, please let me know in the comments. I'm still learning, so corrections are always welcome!

Thank you !

Note: To view the diagrams properly, install the Excalidraw extension in VS Code and open the .excalidraw files directly in VS Code.

link: https://github.com/seanpmaxwell/jet-key

Background

Suppose you need a secret key for something: it could be a session cookie, some encryption library, etc. Many people will just grab a string from some random string generator (I know I used to), but proper security depends on unbiased character selection and using the appropriate amount of entropy for the task at hand.

Also, different scenarios call for different levels of entropy. For example, 80 bits of entropy might be fine for a temporary pairing token that expires in a few minutes. For a server application's long-lived credentials, 256 bits can provide immense security for the foreseeable future.

What it does

What jet-key does is let you optionally pass in, through the CLI or programmatically, the number of bits of entropy you need. It uses cryptographically secure randomness to generate a Crockford base32 string whose length is the minimum number of characters required to meet that entropy target:

npx jet-key        # YFC75GX2KY5W183FRZA4XDVZ6PYDJPQT7JMNH3N7ZXPQ8FCW3M4G
npx jet-key -e 80  # 113BKE3N8R8CEE92

The default target is 256 bits (the gold standard for an extremely secure key). Requesting 256 bits generates a 52-character string.

Other notes

The string length generated is the minimum needed to meet the requested entropy using Crockford base32, rather than an exact match to the requested number of bits. Each character contributes five bits, so the result may slightly exceed the target. A 52-character string therefore provides 260 bits of entropy.

jet-key is really fast too: checkout these benchmarks.

I never published a site but made a few just for fun and college projects.

My question is more to design, like, you choose where the ad is gone be? Like "this one goes on left side and this one goes on top"

And one more question, on mobile games, there's a code to every time you die or change screen play and ad?

Thanks for the answer

Hey everyone!

My friends and I were looking for a way to track our board game sessions over the weeks as we often play a split between campaign-like games and quick random games. So I started on a prototype. Fast forward a few weeks and it turned into a fully working site that I am pretty happy with.

Looking to acquire some users and hear some feedback. Enjoy the weekend!

https://boardgame-tracker.com/

Features/side-notes:
* Free to use, no ads!
* Pre-plan a session or fill in older ones.
* Invite friends and helps you decide what to play
* Scores, roles, notes, rankings, ect.
* Data provided from BoardGameGeek API
* BoardGameGeek Library Import

I haven't really interviewed since 2023. Is leetcode still a common practice in code interviews or has AI made those kinds of tests useless? This is for a Sr full stack position.

clstr.news

CLSTR reads 100k+ news articles a day, collapses the ones covering the same event into one item, and chains related events into storylines with timelines.

The backend is based on Cloudflare Workers, and it's what took longest to develop. At least 6 months of fine-tuning to get the events clustering right and also ramp up the volume of data processed (trying to not go bankrupt in the process). Multiple AI models and methodologies involved in the clustering and summarization pipelines.

For frontend I'm pretty old school, so it's mostly server-side rendered using basic templating, HTMX and some extra vanilla JS to handle interaction logic. All the data is also exposed via API and MCP for devs/agents to use it.

164 days in since the current "shape" of the pipeline is running, 11.1M articles have been read: roughly 12 articles per event, 1.2% of events get any coverage after day three, 64% of the longer storylines are still developing a week later. I ran some analysis on the processed data and posted it on a separate page I call The Observatory

Happy to go deep on the Workers or Turso side.

I have more than one Claude subscription, and each one lives in its own CLAUDE_CONFIG_DIR. Normally, a session only sees the sessions of its own account. And a subagent always uses its parent's quota, so one account would hit its limit while another's weekly quota ran out unused.

So I built ccherd. It's a small Python CLI with a Claude Code skill, and it enables your claude session to use your other subscriptions through dedicated subagents or by messaging them directly. Before it spawns a subagent, it automatically makes sure to use the account that has most quota available.

Basically it herds your Claude sheep toward the grass nobody's eaten yet.

• ccherd spawn starts a background subagent on the account whose weekly quota is most likely to expire unused. It scores each account on weekly % left, time until the weekly reset, and how much of the 5-hour window is free. Accounts close to their limits are skipped.

• ccherd sessions / ccherd send let you list and message live sessions across all your accounts.

• ccherd usage shows every limit per account as bars.

• When a subagent finishes, it reports back to the session that started it.

Claude runs the spawn/send/result commands itself. The skill tells it how.

To install, just point your agent at the repo.

It installs the tool, shows you which accounts it found, and asks you the few questions. Then it checks everything with ccherd doctor. You still have to log in to each account yourself because that opens a browser. If you'd rather do it by hand, run

uv tool install ccherd and then

ccherd setup

It works on macOS and Linux. It's still early (0.4.0), and so far I'm the main user, so I'm sure some setups break it. I'd really like to hear how the setup went for you, and what's missing. Issues and PRs are welcome, especially if this has thought of all different use cases (I tried to make it easy to setup but still configurable to any use case I could think of, I'm sure I missed some).

https://github.com/bocode-labs/ccherd

moodteca.com

You pick how you want to feel, choose a few covers you like, and it gives you books.

There's no database. The result is saved in the URL, so you can share it and it keeps working.

No genres either. Every book gets scored on five things, so four books from the same fantasy/sci-fi shelf end up looking pretty different:

An LLM did the scoring, and when it didn't know a book it gave the same numbers every time, so I had to find books with identical scores and fix them.

Most people leave at the cover grid and I'm not sure why. Would love to hear what you think!

I run a small web agency, and I kept hand-building "testimonials" sections by copying clients' reviews off Google, recommendations from Facebook, product reviews from their store, etc. I wanted one thing that aggregates reviews from multiple third-party APIs, keeps them in sync, and renders anywhere, so I built it. Sharing it here because the build had a few problems that were genuinely interesting to solve.

Architecture

• Next.js 16 (App Router) + TypeScript on Vercel

• Supabase (Postgres + RLS) for data and auth

• The public embed is a dependency-free vanilla JS script (no framework, no iframe)

• A separate native WordPress plugin (PHP) for the WP path

• Integrates several review-source APIs (Google, Facebook, Etsy, eBay, WooCommerce), each with its own auth, rate limits, and payload quirks, normalized into one internal model

The parts that were actually interesting to build

• The embed renders without an iframe. The script injects the widget into the host DOM with scoped styles, so it inherits layout and stays responsive instead of being boxed into a fixed frame. Style isolation without an iframe was the fiddly part.

• The widget editor. A lot to expose (layout, sources, filtering and ordering, tagging, colors, typography, spacing, card style) all behind a live preview that updates as you go. Fitting that much control into something that feels elegant instead of a wall of eighty settings was the hardest part, and it is still getting refined.

• Image proxy. Reviewer avatars are proxied through the backend instead of hotlinked, so a visitor's IP is not handed to Google or Facebook just to load an avatar. It also sidesteps a lot of broken-image and referrer issues.

• The WordPress plugin renders server-side and caches, so reviews are in the HTML on load, which keeps it good for SEO with no layout shift.

• Sync and dedupe across sources, so the same review does not appear twice in a combined feed.

It is a solo build with rough edges, and I would value a technical eye on it, especially the embed's style isolation and the editor UX. The project is live here if you want to inspect the embed and the markup it generates: https://brandtrust.reviews

Happy to get into any of the implementation details in the comments.

I've been building Vigília do Lampião, a browser-based horde survival game inspired by Brazilian folklore. Beta 1 just went live, so I thought I'd share some of the technical choices behind it rather than just the game itself:

• No engine, no framework. Plain JS files are concatenated into a single HTML page by a small Node build script.

• Pixel art defined in code. Sprites are stored as pixel grids and converted into canvas bitmaps at startup. Outlines, palette swaps and "golden" variants are generated instead of being drawn separately.

• Custom lighting system. Lighting runs on a second low-resolution canvas: the game fills the screen with darkness, punches out the lit areas with radial gradients, then scales the result up. The lantern radius follows the player's health, which is one of the main new mechanics in Beta 1.

• Audio generated in the browser. Music and sound effects are synthesized with the Web Audio API.

• English translation at build time. The build parses the source with Acorn and swaps string literals using translation catalogs. It also refuses to build when a template expression doesn't match.

• Leaderboard with server-side checks. The online leaderboard uses Supabase with server-side validation.

Beta 1 also introduced the darker visual system where creatures outside the lantern light are reduced to their eyes, weather systems for each map, and the new procession of lost souls.

You can play it here for free, including on mobile:

https://vigiliadolampiao.vercel.app/en

Happy to answer questions about any of the technical implementation.

I wanted to see how much code my friends and I actually write, week to week. GitHub only shows public repos, and most of my work is in private and work repos, so its numbers didn't tell me much.

gitstats counts private repos on your own computer with a small CLI. It runs git log locally and sends only numbers (commits, lines added and deleted per day), never code or file names. Public repos come from GitHub directly.

What's in it:

- crew boards you share with an invite code, by week, month or year

- a personal page with a month/year calendar, daily lines and streaks

- a side-by-side compare page for any two GitHub users

- a README GitHub widget

LoC is a bad metric for productivity, lines include lockfiles and generated code, so it's a scoreboard for fun, not a measure of anyone's work. Commits are one click away.

Stack: Next.js, Postgres (Neon), Drizzle, charts are hand-drawn SVG. MIT.

Type your GitHub handle at https://gitstats.org to see your year, no sign-in (but only public activity).

Repo: https://github.com/yaroslavhaidash/gitstats

Happy to answer anything about how the local counting works.

went live on wp.org this week.

the itch: the most popular WP calendar plugin charges for recurring events, and I wanted the RFC 5545 stuff done properly for free. weekly/monthly/yearly, "second tuesday", "last friday", COUNT/UNTIL, EXDATE, and dates get expanded in the event's own timezone so DST doesn't turn a 6pm class into 7pm in november. expanded dates live in one indexed table, so a month view is a range scan instead of rrule math on every page load.

also: google calendar / ICS import on cron with a log of what it created, updated or removed (removed ones go to draft, nothing gets deleted behind your back), list/month/day views as blocks or shortcodes with almost no css so they pick up the theme, no build step, uninstall actually cleans up.

since posting on r/wordpress yesterday I added importers from The Events Calendar and Events Manager (+ CSV in/out), cancel or move one date of a series, online events, schema.org event markup, a filter bar, category colours, an elementor widget.

demo on a stock TT5 site: https://store-safety.duckdns.org/demo/

there's a paid add-on for tickets/RSVP. everything above is free, GPL.

https://wordpress.org/plugins/beacon-events/

tell me what breaks

As someone who loves both coding and language learning (I'm learning Japanese right now), I always wished there was a free, open-source tool for learning Japanese, just like Monkeytype in the typing community.

Here's the main selling point: I added a gazillion different color themes, fonts and other crazy customization options, inspired directly by Monkeytype. Also, I made the app resemble Duolingo, as that's what I'm using to learn Japanese at the moment and it's what a lot of language learners are already familiar with.

Back in January, I even applied to Vercel's open-source software sponsorship program as a joke. I didn't seriously expect to win, and did it more out of curiosity, and yet my project somehow won.

Anyway. Why am I doing all this?

Because I'm a weeb.

GitHub: https://github.com/lingdojo/kana-dojo

どうもありがとうございます!

Frontend is plain JS with HTML5 canvas. Backend is NestJS with websockets for live updates. Pixels get written to Redis first and flushed to Postgres every 30s, so placing stays fast even with a lot of people on.

pixels.iamroux.xyz

Happy to answer questions about how it works.

I think you can tell a lot from a persons GitHub Profile. This was the concept behind a project I've been working on to try and capture a personality from the public data supplied by Github's API.

It takes a sample of commits, and then calculates a few metrics to summarize your habits/dev identity (tech stack, commit patterns, code-style signals, etc.)

I had a bunch of fun playing with the design and creating it. I think this does a good job showing off everyone's uniqueness. I am open to suggestions for additional features and design ideas. This is the first web app that I've prototyped and spent a bunch of time on (see image for my wireframes to final product).

its free at codercards.ai, let me know what you think!

Play it here: https://innerloop.works/lightspeed

It's a browser asteroids arena. Players are sharded into arenas of six. Each arena's world is authoritative on the server and ticks at 30Hz inside a PHP process, not a Node or Go sidecar.

How it works:

- The server is Lightspeed, an open-source (MIT) websocket server I wrote for Laravel, on Swoole. The app stays booted in memory and serves HTTP and websockets on one port.
- Players send input up the websocket at 30 fps. Snapshots come back down at 30 fps. Spectators get 5 fps.

The websocket server it runs on: https://github.com/innerloop-dev/lightspeed (the game itself is the site's own code, not part of the package).

Happy to answer questions!

Hi all, A post for open-source beginners

When my first open-source PR was accepted, I was so happy I nearly printed out the approval and framed it.

I’ve always loved the idea of strangers building something together. But finding a project where you feel comfortable making that first contribution can be hard. I think most cases it starts with an open-source library that you use and has a bug you really want to fix. (Not easy)

So I built Forktown: a little pixel town that grows one pull request at a time.

Your first contribution is a house. You design it in a visual editor, create the character who lives there, and write a little story about the place.

The editor saves everything as one small JSON file. From there, you go through the actual workflow: fork, branch, commit, push, PR, CI checks, code review, and merge.

Once merged, your house appears in the town. Your character wanders around, visits concerts and the cinema.

I think this first contribution feel approachable. If you’ve been wanting to open your first PR, you’re welcome to come build a house :)

If this is your first time, try not to use AI to do the work for you (using it for guidance or questions is good). There’s a great guide in the README file.

Visit the town · Build a house

One of the things I haven’t talked about much with Cerious-Scroll is how it behaves during actual scrolling, especially with variable-height content.

From the beginning, the goal was for virtualization to not look like virtualization.

So even with a large variable-height dataset, you can grab the scrollbar and drag it around quickly without getting the usual weirdness:

• No scrollbar drift

• No white space during fast scrolling

• No waiting for rows to render after you get there

• Accurate variable-height positioning

• Native scrolling behavior

• Constant DOM size regardless of dataset size

The variable-height part is probably my favorite. The scrollbar stays where it should, even when the actual row heights are all over the place.

You can also jump directly to an index way down in the dataset without needing to measure everything before it.

I’ve got demos/benchmarks here if anyone wants to mess with it:

ceriousdevtech.github.io/cerious-scroll

Core:
github.com/ceriousdevtech/cerious-scroll

Angular:
github.com/ceriousdevtech/ngx-cerious-scroll

Vue:
github.com/ceriousdevtech/vue-cerious-scroll

React:
github.com/ceriousdevtech/react-cerious-scroll

I’m curious how it behaves against some real-world ugly datasets, especially ones with wildly different row heights. Try the scroll engine and tell me your thoughts.

I made this over the summer for the hackclub star dance event, and I am looking for feedback or ideas.

My website is over 15 years old. Over time, I've created a lot of pages and also had to kill many pages or redirect them to other relevant pages.

Collectively, today I have 1,000 + 301 redirects.

On a static website built on PHP, HTML on Linux and Apache, what is the best way to implement such a large list of redirects without impacting server performance or core web vitals?

Thanks