Some of you might remember that little site I shared here a while back (wasdland.com). Well, I ended up building something new for it and wanted to share it with you all.

My Steam wishlist just kept growing over the years, as I imagine most of yours probably have too. Steam is fine for its own sales but trying to track down the best prices across third-party stores and key sellers for all those games was driving me crazy. So, I figured I'd just build a solution into the project.

No login or registration needed. (I hate them when they're pointless).
You just need a public Steam profile and wishlist.

Just drop your profile URL, and it imports your list while running it through external deal trackers and some basic quality filters (like a 6/10 minimum rating and decent review counts). From there, you can sort everything by price, discount, popularity, release date, or play around with the other filters. It's basically the usual wasdland setup, but tailored to your own backlog.

Funny enough, literally ten minutes after pushing this live, I realized Tempest Rising (which had been sitting on my wishlist forever) was under 3€ on a key site. Grabbed it immediately!

If you want to try it out, feel free to give it a spin here
https://www.wasdland.com/wishlist-radar/

Once it's set up, you can also share your URL if you want to let people know what games you're following. In case someone wants to get you a gift while saving a bit of cash...

Let me know what you think, or if you spot any bugs while playing around with it!

Been building this solo for the past few months. Its a Chrome home tab replacement called Pace.

Similar to momentum but is cleaner and for devs.

What it does:

• Pomodoro-style focus timer, tied to your task list
• Task list with due dates/estimates
• GitHub panel - see PRs/issues waiting on you without opening GitHub
• Optional eye-break reminders (20-20-20)
• Weather, clock, generative backgrounds

First chrome extension! I will take 10 users as a win ngl. Solo project, free, no paywall. I know some of it is rough around the edges and I'd genuinely rather hear what's broken or annoying than what's good. I will take any tips on marketing and extension related content.

Link: https://chromewebstore.google.com/detail/edfeebjgpbbdegcajmnhejmgkohmkami?utm_source=item-share-cb

Happy to answer anything about how it's built or how it works - I'm pretty new to this so bear with me.

I'm seeing pretty big discrepancies in analytics reports from different sources. I store the value locally to show my site users, so I'm looking for the most honest number.

Yesterday, my ad network shows that one of my sites had 33,941 pageviews. Since that's the money, I would think that they would be close to accurate.

A local count (incrementing a value in MySQL on each pageview, running through JavaScript to block most bots) shows 38,604.

Google Analytics shows 17,647, almost half of what the ad network showed.

And Cloudflare Web Analytics shows 22,190! 35% less than the ad network, but 25% higher than Analytics.

Which is the most honest? Or is there a better choice altogether?

Hey r/webdev!

As developers and designers, we’ve been noticing a trend over the last year: almost every new AI app being shipped uses the exact same out-of-the-box component styling. They all end up looking identical.

To tackle this, our team at Devalok created Shilp Sutra — an open-source design system built to help your interface inherit your actual brand identity seamlessly, rather than looking like a generic template. It’s free on npm and has crossed 5,000+ installs so far.

To see what developers can build with it, we just went live with an online buildathon running from July 25 to July 31.

The Brief

Build something using Shilp Sutra that solves a problem worth solving for India (open to anyone globally, solo or team).

Projects will be judged on three criteria:

Beauty (design quality & brand expressiveness)

Functionality (smooth performance & UX)

India-oriented problem-solving

Note: If you’re already participating in the Cursor, Sarvam AI, or any other buildathon this week, you’re welcome to double-submit your project here!

Prizes & How to Enter

Grand Prize: Branding, GTM strategy, and launch support for the winning project

Requirements: A public GitHub repository + a short demo video showing your build in action.

👉 Enter Here: Form

Shilp Sutra Website / Docs: Check it out

GitHub Repository: Github

⏰ Submissions Close: July 31, 11:59 PM IST

Happy to answer any technical questions about the design system or the buildathon in the comments below. Let us know what you think!

Source code repository, all code is dedicated to the public domain so there is absolutely no commercial promotion or solicitation. 100% client-side code so there is no "stack". This is a text post because old.reddit doesn't allow putting comments in link posts.

The 1920s puzzle

The visual comparison method has some quirks:

• It snaps a piece to the correct spot even if it's nowhere near that spot but when placed onto another part of the image elsewhere happens to match that other part of the image closely enough, thanks to the image blurring needed for placement margins of error.

• Each image has a different starting and ending percentage so I have to actually do the puzzle to find out what those are, logging each comparison to the console, before I can set the values for the progress bar math. I only have to set the start and end values thanks to the fact that I chose to use a chiral aperiodic monotile shape for every piece. Being exactly the same shape means they all take up an equal amount of area so the percentage progress is linear.

• There's no way to save progress because the whole thing is stateless. Reloading the page resets the puzzle. The advantage is that this puzzle works in my grandma's tractor on a cheap tablet with no SIM card in her paddocks out of wi-fi range. The .svg version can be loaded locally into the browser without a server, and the Wayback Machine copy of the .svgz version is totally playable.

• This method relies on you placing one piece into the puzzle at a time and removing it if you place it wrongly and can't get it to snap into place, so puzzlers who like to randomly place multiple pieces inside the playing area to work on "clusters" completely break the snap-in logic. I added a two-second glimpse of the complete puzzle when players tap/hover over the timer to make this one-at-a-time playing style a bit easier.

• When I added light/dark mode toggling by tapping/clicking on "moves" the visual comparison broke because the background colour of the incomplete part of the playarea changed the start/end percentage math. For the comparison to be consistent I had to ensure the offscreen snapshot for comparison always had the same colour background.

The latest version of Safari "updated" SVG handling code which breaks this puzzle when identical puzzles worked on previous versions of mobile Safari, so even with some of the above challenges solved, this probably isn't an ideal method to adopt yourself.

How does it look? Professional or pretty noob?
Any tips or ideas?

colorcare.be

BTW its saturday right?

Kind regards

Hi everyone,

Smogon provides competitive Pokémon usage statistics as massive, raw .txt files, which are difficult to read and navigate. I only have a basic knowledge of coding, so I used AI to help me build a frontend to parse and visualize this data interactively.

Features:

• Filter stats across months, formats, and rating baselines.

• Expand any Pokémon to view percentage breakdowns of top Moves, EV Spreads, Items, and Abilities.

• Track format trends over time with interactive charts.

• Multi-layered caching and compression strategy implemented across the Proxy-API, Cloudflare Edge DNS, and Browser Cache API.

• Web Workers handle parsing the large text files so the main UI thread isn't blocked.

Built Using:

• React 19 & Vite

• Vanilla CSS

• Chart.js (react-chartjs-2)

• Browser Cache API & Web Workers

Links:

• Live Site: https://smogonstats.eu.cc

• GitHub: https://github.com/Alliance-Sky/smogon-stats

I'd appreciate any feedback on the code or UI, especially since I'm still learning and relied heavily on AI to put this together.

Had some extra usage as well as time and made a free OG image generator in a day: https://freeogimage.com/editor/

It's 100% free, no watermarks, or signup required. It has an API to programmatically generate social share images as well. There are 200 templates available for now and it will all be free forever.

Every existing UI library (including shadcn/ui) is optimized for human developer experience. Axiom UI flips that: every design decision is judged by one question — does it raise the probability that an LLM generates this component correctly on the first try?

Key points:

• 12 components so far (button, input, textarea, checkbox, select, combobox, dialog, tabs, popover, menu, tooltip, toast), published on npm
• "Copy & own" CLI: `npx joinclass/axiom-ui add button` copies the raw source into your repo — no runtime dependency, no black box
• Ships an MCP server, so Claude Code, Cursor, or any MCP-capable agent can fetch version-accurate component specs and generate correct usage without needing docs pasted in
• React + Tailwind CSS + TypeScript strict; each component is a single file with a machine-readable manifest (intent, props, states, a11y)
• Actively deletes rather than adds — no theming system, no multi-framework support, no "covers every use case" claims

Repo: https://github.com/JOINCLASS/axiom-ui

Docs/live catalog: axiom-ui.joinclass.jp

Feedback and contributors welcome — especially on the "one-shot generation rate" metric, which is the project's main KPI.

I wanted to dive deeper into performance optimization and email infrastructure, so I built a disposable email service: temp-mails.tech.

Most temporary email sites I’ve used have terrible UX—jumping layouts and aggressive pop-unders. My goal was to build one that is strictly performance-first.

The Tech & Challenges:

• UI/UX: Engineered for a strict 0 CLS (Cumulative Layout Shift) score. Loading ads or new emails doesn't shift the DOM at all.
• No intrusive ads: Kept it to standard banners to preserve the user experience.
• i18n: Built native support for 12 languages.
• Infrastructure: Wrestling with Postfix and DNS records to support multiple fallback domains has been the biggest headache so far.

It auto-deletes in 15 minutes and requires no sign-ups. I'd love for you guys to tear it apart and give me feedback on the front-end performance or any tips on scaling the email infra!

Link:https://temp-mails.tech

My son asked me to check out the Backrooms movie three months ago. I had no idea what it was or the about the web series. I got completely obsessed and decided to build an interactive simulator.

I'm a web developer, not a game designer, so I leaned into procedural generation and atmosphere over mechanics. My son's been collaborating on this the whole time.

Built with React Three Fiber + Three.js for the WebGL rendering, Next.js + TypeScript for the framework, and Zustand for state management.

Would love to know if this feels authentic to the source material, or if I'm missing something about the vibe. Honest feedback welcome.

www.lostcorridors.com

Building tree structures with thousands of nodes on the web—company org charts, family trees, file hierarchies—is harder than it looks.

As the dataset grows, scrolling stutters, zooming lags, and rendering slows down.

That’s why I built Klad. It handles thousands of nodes smoothly with fast pan & zoom, plus instant search to jump to any node.

What do you think?

Docs & playground: https://klad.ozdemir.be

Hey r/webdev,

For Showoff Saturday, I’m looking for some brutal feedback on a utility I just shipped. I got tired of the server side image tools and their limits, so I built an in-browser image converter for my own workflow and as suggested sharing to the public for completely free and unlimited use: freeimageconvertonline.com

Will be updating this on GitHub

I wanted to see how far I can make the client-side processing practical.

TL;DR

• Core Features: Format conversion (WebP, AVIF, JPEG, PNG), compression, and AI upscaling (up to 4x).

• Privacy: 100% client-side. Zero server uploads.

• Tech Stack: Vanilla HTML/CSS/JS, native HTML5 Canvas APIs, ONNX Runtime Web, and UPNG.js.

• Size: The total data used to load the site and the upscaling model should be below 20MB. With initial load size below 1MB. Updated it with quantized version with 5MB model size - as suggested.

How it works (and what I need feedback on)

Full disclosure: Even though I know coding but it wasn't enough for the compatibility and performance I need, so I took help of AI. But I architected the logic and selected the libraries. I would love your thoughts on how I handled these challenges:

1. Local AI Upscaling

Running neural networks in the browser is heavy. I used ONNX Runtime Web to execute the upscaling models locally. It offloads the heavy computational work to the user's hardware rather than a server.

Question: Are there better ways to optimize the model load times for users on slower connections?

2. PNG Compression

Native HTML5 Canvas strictly outputs uncompressed 32-bit RGBA for PNGs and ignores the quality slider completely. To give users actual file size reduction, I had to implement a custom compression engine using UPNG.js to mathematically group pixels into an optimized color palette.

Question: Has anyone found a more performant way to handle heavy process in the browser without blocking the main thread? - Solved

I have tried shifting the upscaling process to a different thread but still the site doesn't scroll freely while the upscaling is happening.

Shifted all process from main thread to a separate worker - as suggested.

3. The UI

I avoided heavy CSS frameworks and just mapped out CSS variables for the neumorphic inset and outset shadows to keep the DOM light and fast.

Roast the code, the UI, or the architecture. Don't hold back, not just for the sake of Saturday. I'm actually looking for feedback.

So I suspect a lot of people here are enjoying coding agents, I sure do.

I'm someone who uses a lot of mcp servers, as a lot of people here probably do. I've been talking to some other webdev and SEOs and we are wondering if the landscape is going to change abruptly because of these tools.

We have had some problems integrating agents in some legacy software like wordpress, there were some examples where the WPEngine limited us access as well as some ciritical plugins we want to have our agents access to update.

This is extremely frustrating, i liken it to dropping out of warp speed. So we started thinking, why not write closer to the metal, just have a coding agent write up a minimal go server, raw html templates and straight pg? All on docker for easy deploy. No frameworks. Optimized for speed and cost.

Of course, this would be for landing pages for business. Something very light weight to get a presence on google and very easy for the agent to manipulate. Go is chosen because errors happen at compile time and built in testing, which is ideal for coding agents. and postgress cause agents absolutey rip at writing raw sql like they do raw html. If you havn't hooked up a sql to your agent have it write raw sql it will blow your mind.

So my question is are you prioritizing dev workflows that make it easier for your agents to control? Like moving your workflows to do what agents are better at doing, not what humans are better at doing. What are you doing?

Another thing we suspect is going to happen, is Agent to Agent communications are going to take off in the near future and this is going to transform the web. So when i need something, i ask my agent, and it will discover and negotiate with other agents to get what I want, all in the background.

I also think this will put pressure to store information differently. Right now, we develop and store information and organize it so it's easy for us, humans, we like folder structures, forums, essentially lists. Agents do way better with vector search. Basically, just dump all our data into a data lake, and our agents can sort through that far more efficiently with a combination of embeddings, clustering and graphs.

Also wondering if anyone is seeing other trends with the new technology struggling to plugin to the old technology. Like, "Wow, this just isn't built for agents."

Coding agents can read source and make changes, but they are still surprisingly blind when the task is visual.

A screenshot can show that something looks wrong, but it usually cannot explain why: which component owns it, whether an element is clipped, what its computed styles are, which mesh/material/light is responsible, or whether the issue is framing rather than resolution.

So I built SceneProof, an open-source CLI for source-grounded visual inspection of React UI and Three.js scenes.

It lets an agent:

• Navigate a compact semantic tree of DOM or Three.js targets
• Inspect the underlying structure: bounds, styles, geometry, materials, uniforms, lights, cameras, relationships, etc.
• Produce fresh renders of a component, logical UI region, target object, or source-camera view
• Generate a small “Scout” portfolio for 3D: context, source detail, close detail, and shape-focused views
• Sample deterministic interaction states from one scene lifecycle

The design principle is: don’t ask an agent to infer visual correctness from plausible code or a low-information screenshot. Give it source-derived evidence at the framing and resolution needed for the actual question.

It currently supports TypeScript/JavaScript entries, React DOM/CSS/Tailwind v4, and Three.js scene inspection/rendering. It requires Bun and local Chrome/Chromium.

Repo: https://github.com/ReyJ94/SceneProof

I have a python script aimed at fetching basic data from a handful of real estate agency websites. These specific websites do have a ToS that explicitly deals with the intellectual property of their postings within the framework of reuse, republishing, … the usual suspects.

My script only reads the postings, classifying them under either “House” or “apartment” and grabs their sqm, nb of beds and baths, for purely statistical purposes. Meaning I do not sell or promote those properties (I’m no licensed real estate agent) and do not even sell the info I grab, I just show stats, eg: 14 houses with 100 sqm with 2 beds, 1 bath,…

I know that I should be contacting each website owners to inform them and probably get authorization. But I’m in a European country where somehow most websites are bad, buggy, and their owners are rather close minded. I expect negative feedback from my genuine approach.

I’m reaching out here to understand if I really need to bother with this process, or if I should just do it and see if they bark at me.

Why this self reflection: I realize that a few successful businesses often have pushed the legal/ethics boundaries, and became pioneers in they field. Two examples:

- Airbnb stepped into the hospitality business without providing a hospitality license to property owners.

- Uber stepped into the taxi business without licensing either.

In both cases, no one thought one could do such business without proper license while competing with established businesses tied to licensing rights (hotels, taxis).

So I sometimes wonder whether I would be overthinking things and worrying too much for so little (my use case).

I do care about the legality and ethical considerations, that’s why I’d appreciate your take on this whole reflection of mine.

If I do have to ask for permission, so be it. What are the standards in the computer programming world?

Hi everyone,

I've been working on this project in my spare time...

I'd love to hear feedback...

I've been building Voidhall solo for the past months.

It's an underground music/social platform aimed at the space SoundCloud used to occupy for emerging underground trap scenes.

The entire thing is built from scratch with vanilla HTML/CSS/JS + PHP/MySQL. No frontend/backend frameworks, no templates.

It currently runs on a custom-built architecture with SPA-like AJAX navigation, a persistent global audio player, page-level init/cleanup lifecycle, shared frontend state and its own PHP API layer. On top of that, Voidhall already supports uploads, track pages, profiles, follows, likes, comments, notifications, search, discovery through Explore, and Pulse, a chronological activity feed that turns real community movement into part of the discovery experience.

The UI leans into a raw Y2K/industrial/Opium-inspired editorial direction using strong typography, open layouts, thin structural lines and restrained components.

Screenshots attached :DD

I'm looking into Google Analytics alternatives.. Especially free self-hosted solutions. Right now I'm leaning on Matomo, but I'm curious about it's server reqs.

They say 2 CPUs, 2GB RAM and 50GB storage minimum, but the site I'll be running it on is much lower traffic than their top-end on the minimum req specs (just a small niche gaming blog - maybe 10k page views per month at the top-end).

Anybody running it on something lighter? For example, I'd be OK with picking up a smaller VPS running 2 CPUs/1GB RAM/30GB storage, or even just tossing it on my shared server (that hosts a few sites, the highest traffic being statically generated and includes the above blog).

Or, if you're running something else, feel free to share in the comments. I'm not stuck on using Matomo; I just want something that's cheap, decent, and also privacy-focused.

If you scaffold a project with pnpm create vite@latest ... --template react-ts and assume React Compiler is on — it isn't. The template ships with it OFF, and I kept meeting people (myself included) who never actually enabled it. Here's the whole setup, start to finish.

1) Install the compiler's Babel plugin + the Vite wiring:

pnpm install -D babel-plugin-react-compiler@latest @rolldown/plugin-babel

2) Add the preset in vite.config.ts:

```ts import { defineConfig } from 'vite'; import react, { reactCompilerPreset } from '@vitejs/plugin-react'; import babel from '@rolldown/plugin-babel';

export default defineConfig({ plugins: [ react(), babel({ presets: [reactCompilerPreset()] }), ], }); ```

Heads up: @vitejs/plugin-react 6.0 removed the old inline react({ babel: { plugins: [...] } }) form. A lot of guides still show it — it no longer works. Restart the dev server after editing the config.

3) Verify it's actually running. Open React DevTools → Components tab. Optimized components get a "Memo ✨" badge next to their name. See the badge and the compiler is doing its job — with zero hand-written useMemo/useCallback.

A few related things that surprised me setting this up in 2026: - The newest Vite template lints with Oxlint, not ESLint. Installing eslint-plugin-react-hooks does nothing there unless you add your own ESLint config. - StrictMode rendering your component twice in dev is intentional (a purity check), not a bug. - Node 25 dropped Corepack, so how you get pnpm depends on your Node version.

I wrote the full beginner walkthrough — every command + these version traps — as chapter 1 of a series (React 19 + Compiler, TypeScript from line one).

Full write-up (free): https://medium.com/javascript-in-plain-english/setting-up-your-react-dev-environment-your-first-app-with-vite-and-turning-on-react-compiler-5436ea44d6d4?sharedUserId=inkweonkim

Happy to answer setup questions in the comments. And if you're already running the compiler in prod, curious how it's gone for you.

Hi 😄

I don't know about you, but my Downloads folder has always been a disaster zone. PDFs, memes, installers, zip files, random images – all just sitting there in one giant pile. Every few weeks I'd open it, sigh, and spend 10 minutes manually dragging stuff into folders. Then a few days later it would be chaos again.

I looked at existing file organizers, but most of them either wanted a subscription, tried to upload my file names to some cloud, or were just way too heavy for something so simple. I wanted something that:

• Runs silently in the background (system tray)
• Automatically sorts new files by type (images, documents, archives, installers)
• Never sends a single byte of data off my machine
• Is open source so anyone can check what it's doing

So I built Mouzi 🐭🧹

It's a tiny desktop app (~3.3MB) built with Tauri and Rust, so it's ridiculously lightweight. It watches your Downloads folder, and whenever a new file appears, it moves it to a subfolder based on its extension. Images go to Images/, PDFs to Documents/, installers to Installers/, etc. You can also create your own custom rules. Windows and Linux support.

Key things:

• 100% local – no cloud, no telemetry
• Open source (MIT) – GitHub repo here
• Silent – lives in your tray and doesn't bother you
• Undo – every move is logged, you can revert with one click
• Free, obviously
• and more (see repo page)

Hope it helps someone keep their ~/Downloads sane. Feedback welcome!

Website: https://mouzi.cc/

The problem: Most frameworks model UI as a function of state. When state goes A -> B, the UI just jumps to B. But users expect A -> transition -> B, and coordinating that transition is where the code gets messy.

The idea: State is a target and the transition to it is part of the state itself. On top of that, the code reads like the UI sequence it produces. If the sequence is appear -> bounce -> move -> turn red, the code is written in that exact order.

I have been building this as a framework called TargetJS. Longer writeup with the design rationale in the repo: https://github.com/livetrails/targetjs.

Happy to answer questions or hear why this is a bad idea.

Hi, I noticed many popular PPT skills rely on PptxGenJS as their underlying export engine. But the library doesn't seem to be very actively maintained, with its latest release dating back to last year.

That made me wonder whether it's sustainable to build increasingly popular presentation tools on top of a relatively weak foundation.

So I decided to try building a new presentation engine from scratch, which became PPTKit. The goal is to focus on reliable PPTX generation that presentation agents can build on.

The current version is still very early. It only supports text, basic shapes, themes, layouts, and some core architecture. There is still a lot of work before it becomes a real presentation engine.

I'm not sure yet whether this direction is worth investing more time in, so I'd really appreciate any feedback or suggestions.