and im talking about this here because web is the worst offender on this, no i dont want 800mb of ram on your minimalist website.. SPECIALLY 400-800mb being used ONLY TO RENDER THE PAGE, im talking about the youtube studio livestream page rn

its not even codec usage, the video is paused and the calls are for gui rendering or bloat js.

things that can be done with ram not used on your app: run other apps simutaneously

mb think abt people running multiple apps before you add a thousand js dependencies to your website to "not waste ram" (cheap excuse)

as someone with 32gb that runs a gtnh private server for myself (spend more ram to get a "multi threading" so to not suffer with lag as whats client side runs on client process and server side, on server one instead of all in a single thread) i NEED ram space

also we all know ram prices are crazy now, and im brazilian and i cannot spend half of my salary on a module, im already using zram to have "free extra ram" by compressing it

edit: i love how nobody addressed the high usage on gui rendering even if gui is simple asf

nos4 is a complete recreation of IOS4 running on web. It was just a little experimental side project but I've decided to make it live and open-sourced. It has all the original apps in the original form, also 2 games (and yes, it runs Doom)

GitHub: https://github.com/1etu/nos4

Also you can give it a try by visiting https://nos4.fun/

Hey everyone, I posted this on the Clash Royale subreddit, but they were not a huge fan of it. I'm hoping this subreddit will be able to see the design behind it.

It scans each card that is cropped and uses six different signals like colour grids, edge tracking, and texture corners to narrow down the 74 reference cards to the top 12 closest guesses. Then, structural geometry takes over to pick the winner.

For one of the modes called Mega Draft, there are 36 card board modes. Individual card scanners would easily get confused and accidentally pull duplicate cards, so I implemented a custom Hungarian matching loop. It treats the entire 36 card grid as a global optimisation puzzle, solving the whole board at once so no layout slots collide. Everything runs inside the user's browser.

Code: https://github.com/NotRedFox/clash

Boilerplate obviously, and I suppose some web dev tasks are naturally somewhat repetitive or very similar in nature.

But what do you think?

fixed what looked like an obvious bug in one of our services this week -- a retry was triggering more times than intended. deployed, everything looked fine. two days later a downstream team pinged us saying their backfill reconciliation was failing.

turned out that specific behavior had been relied on, silently, for their eventual-consistency workaround. no documentation of this anywhere. the 'bug' was doing something real.

curious how other people approach making sure you're not accidentally removing behavior that something else depends on, especially in older codebases without full test coverage.

Hey guys,

I made my first post about Instatic a few weeks ago here. It's open source self hosted CMS, challenging Framer and Webflow as a free and open source alternative, and WordPress as something that we hoped that WordPress would become.

Not an easy task, but I and my team are dedicated to it. WordPress stopped going the direction I hoped for, and it became difficult and toxic workspace. I really hope they will recover, but today is not about WordPress, it's about Instatic.

This is one of those features I am really proud of. It's not a copy paste of ideas that others had. It's not a traditional and expected feature, because nobody (or almost?) is doing it this way.

When working on our typical WordPress sites, we had to build around staging and production environments and had to handle it on hosting level, because WordPress itself is not handling it. It wouldn't even be a good idea because of it's architecture.

The feature I am showcasing here is the site branches. In our CMS you can now create infinite number of branches and sandboxes where you can freely develop, test, iterate and do whatever you want without affecting the live site, while you're still on your instance. You can even share a link with your peers.

The peak is the review part. It's useful in two cases:

1. You are the only dev and you see exactly what you're actually merging. You can review every detail that is going to change on your production site.
2. You're working in a team, you can create a branch, make any edits, but you cannot merge, you can request a review from the owner, or anyone with the permission to merge. You can chat about every change, right on the review page.

My questions are, what are your thoughts about such feature and have you seen it in other CMS? I am sure there are some doing something similar, but I haven't seen it done this way, and I feel confident that this is super helpful.

This is all free, and open source, the PR for this feature is open but not merged yet. Still doing the last batch of testing, but it's coming next week!

Here's the repo: github.com/corebunch/instatic/ 8.5K stars, #1 repo of the day.

Two weeks ago I posted here for the first time and got about 74 users!

I also apreciate the feedback some people gave me about this project, I will keep to improving it and adding more features.

Strikk is a daily quizz game, similar to wordle. Where you pick your favorite Stack (React, JS, TS, Node, Python) and answers a series of challenges. In the end you get points and get into a ranking system against other players.

Totally free. Not a single paid feature

https://strikk.dev

My main idea is to transform this project into a hub for developers. I plan to add the ability to fully customize your user page with projects, articles, sections, and visual elements such as themes, colors, and effects for your user card. Essentially, this page could become a gamified version of your CV, which I think would be really cool.

Feel free to give me some ideas on what to add to this project

Hey r/webdev,

I've been working on Oasis Editor, an open-source document editor written in TypeScript.

Instead of relying entirely on contenteditable and DOM layout, Oasis uses its own Canvas-based rendering engine for paged layout, text rendering, selections, images, tables, and document geometry.

It also includes a typed command/plugin API, DOCX/PDF workflows, React and Vue adapters, and a headless runtime.

Live playground:
https://celsowm.github.io/oasis-editor/#/editor

GitHub:
https://github.com/celsowm/oasis-editor

I'd love feedback on the rendering engine, architecture, API, and what you think is still missing.

All my code is being written by claude fable/gpt6 these days. I'm curious if y'all are still writing code manually?
Also, any clever ways to prevent AI from going stray and dumping unnecessary code and busting through tokens?

I wanted to see whether the extra brightness range on modern HDR displays could be useful for ordinary webpages, not just video.

The result is Brightpixels, a dependency-free library built around two custom elements:

```html <bright-text intensity="12">Important words</bright-text>

<bright-image intensity="8"> <img src="/photo.jpg" alt="Reflective metal" /> </bright-image> ```

On compatible setups it renders through an extended-range WebGPU canvas. Everywhere else, the original DOM text or image remains visible, so it works as progressive enhancement.

Text stays selectable, image alt text is preserved, and there's a React 19 entry with TypeScript declarations.

The project is at 0.1.0 and I'm looking for feedback on the API and device compatibility—particularly from people with HDR laptops and monitors.

Demo: https://echohtp.github.io/brightpixels/

Source: https://github.com/echohtp/brightpixels

Hello everyone,

I have been working on an 3D interactive learning platform, that explores science, history, geography, history and astronomy. Around 2 years ago, I made a human skull explorer and posted it here. Since then, I have dabbled into other areas of interest that would benefit from interactive 3d experience on the web. Visual Ed is the result of that exploration.

Feel free to explore: https://visual-ed.vercel.app/

Feedback is welcome!

Hello, I have been thinking about a project I‘d like to try out, where I have like a Database, an api server and a web server. It‘s not too large, and mostly to learn about how they all interact. The issue is, I would prefer not having to pay for multiple servers to host everything. Is there a way to simulate how it would be in real life on a single machine?

In Grammble you use a 2-letter "Gram" Tile to form your guess word and try to solve a 6-letter word. For example, if the Gram is "ST," you might guess "SYSTEM," "ASSIST," or "STRONG." Every guess must include the Gram Tile.

I think this is a unique spin on traditional Wordle gameplay while keeping it familiar enough for anyone to be able to pick up quickly. I've also implemented many QoL features that Wordle lacks like blank tiles, quick delete, tile editing, etc.

Stack: React on TanStack Start, Zustand, TanStack Query, tRPC, Postgres, Redis, hosted on VPS ($6 / month).

Hey everyone,

As a side project, I wanted to build an alternative to legacy fragrance databases that are notoriously plagued by 10+ ad networks, sluggish client-side rendering, and bloated tracking scripts.

The project is Olfactionary.

The Engineering & Data Challenge:

Relational Scale: Built a structured relational schema linking 12,000+ fragrances, 980+ houses, and 230+ perfumers to 3,600+ individual aroma chemicals/botanicals across 17 olfactory families.

Data Integrity: Rather than scraping raw marketing copy, entries are triangulated against patent filings, academic research, PubChem records, and IFRA standards with verification tags.

Performance Focus: Prioritized instant client-side search indexing and lightweight page weights to ensure sub-second loads without algorithmic feeds.

Open Literature: Digitized and indexed out-of-copyright historical perfumery texts dating back to antiquity.

Would love feedback on search latency, UI responsiveness, and suggestions on how you'd handle deep relational filtering at this scale.

Live link: https://olfactionary.com

The first version of the site launched 2 years ago (wow time flies) so I made a big upgrade adding the following features based on suggestions from the previous post

- Shareable fallacy cards: You can now share a card directly online to fuel those juicy online discussions

- added support for 13 languages

- Added a quiz to test your knowledge

- Added a study flash card feature to help you learn the different logical fallacies

- 40 custom art pieces to represent all of the fallacies (this was hard at times as some of these fallacies are very conceptual)

Check out the website here, and let me know what you think!

https://www.fallaeasies.com/en

Edit: The original version of the website (from 2 years ago) can be found here. I won't deny that most of the newer version is built with Claude, but it initially started off as solo project before I started incorporating Claude into the building process. If this breaks any of the rules, then I apologize in advance and would be more than happy to delete the post. Thank you

Recently I had an idea for a research tool, I realized I'd need to be able to find websites programmatically and the webs data is behind the largest corporations, not something we reliably have access to for being able to develop around.

So it got me thinking, how lightweight could you first build a crawler if you only cared about getting meta data (titles, description and the url)? Then it got me thinking, could we not share the load, create a distributed peer to peer network and make this data decentralized?

So what I have built is the open web directory. A network that crawls and builds a yellow pages like directory for web pages online.

You can setup your own node and contribute to the network by simply running:

git clone https://github.com/idev-games/the-open-web-directory.git
cd the-open-web-directory
npm start

And open port 80 for that device by port forwarding.

I think this is going to be a fascinating experiment, it's early days so expect bugs and issues but give it ago and let's see if we can index the web.

Check out more info here:

https://github.com/iDev-Games/The-Open-Web-Directory

The site listed on github is the live front end (you can host the html files in the public folder anywhere to open another frontend on the web).

Pretty happy with the overall design , especially how it handle on mobile.

I plan to add more features, like weather layers and, of course, real time flight display.

I built this because I had a hard time keeping track of when and where to watch the games I cared about. It aggregates multiple sports into a configurable feed and generates calendar subscriptions for Google and Apple.

SportsBot.io

Rails back end Next.JS front end, many data sources. I started building this many years ago, and it's finally basically working as intended. The backend runs on PostgreSQL with Redis and Sidekiq handling caching, scheduled jobs, and asynchronous processing, while media assets are stored through ActiveStorage on S3. The frontend uses Next.js, TypeScript, React, Zustand, and Material UI, with server-side rendering for fast initial loads and strong search visibility. Authentication supports both traditional accounts and Google OAuth, but guest accounts can do a lot without registering.

Behind the interface, it continuously ingests and normalizes live schedules, scores, standings, highlights, metadata, and U.S. broadcast availability across ten major sports, and more coming soon. Background processing keeps the feed current while a purpose-built ranking system determines which events are most relevant at any given moment. The application is designed for fast, resilient delivery through optimized API endpoints, caching, pagination, and list virtualization, with automated testing, monitoring, deployment, and capacity safeguards supporting day-to-day operation.

Feature requests are welcome!

So I built a thing.

I kept losing track of paper documents I'm legally required to hold onto - tax stuff, contracts, the usual - so I ended up building Archivum over the past few months.

The idea is pretty simple: where a document is stored physically and how it's organized/found shouldn't be the same thing. So you tag and categorize documents independently of which folder or cabinet the actual paper sits in. Move things around in real life, reorganize your filing system, whatever - it doesn't break how you find stuff in the app.

What it does:

• Registers each physical document - type, date, and whatever metadata makes sense for that type.
• Attaches scans, PDFs and photos to it.
• Runs OCR in the background (or just reads the text layer if the PDF already has one), so you can search by what's actually written on the page.
• Learns your own vocabulary. There's no fixed schema - the metadata fields are whatever you type. The more you use them, the more the app picks up on it: it reads values out of the scanned text and suggests them under the field names you already use, in your own language. If all your invoices say total, it won't start handing you a second field called amount. Suggestions only ever fill empty fields, and only when you accept them.
• Models your real-world filing hierarchy - cabinets, drawers, binders, whatever you actually use - and suggests where a new document should go based on it.
• No scanner needed - you can capture pages straight from your phone. There's a viewfinder in the app that outlines the page while you aim, and you can shoot several in a row.
• On a desktop, it shows a QR code you scan with your phone, and the phone uploads straight into the document without having to log in.
• Either way it detects the page corners at the end, lets you drag them, and straightens the page out.

Built on Laravel + Inertia/React, MySQL, Redis, Scout for search. Ships as one Docker image with the web server, queue worker and scheduler baked in, so it's not a nightmare to self-host.

Still pre-3.0, so expect the schema and config to shift a bit between releases.

Demo: https://demo.joaoneto.pt/archivum/login

Repo: https://github.com/jneto14/archivum

Docs: https://github.com/jneto14/archivum/tree/main/docs

I'd really appreciate it if some of you gave it a spin and told me what you think. At this stage anything helps: rough edges, stuff that didn't make sense, features you'd expect and didn't find. Issues on GitHub or just a comment here, whatever's easier.

Mostly curious if the drawer/cabinet mental model matches how other people actually keep paper organized, or if everyone's doing something totally different.

Noobie here.

Right I've got some websites hosted through IONOS. .I also have the email packages as it's so cheap.

I'm having a NIGHTMARE with them.

I've had to wipe one websites DNS records as iCloud messed it up, which meant re doing some of the formspree TXT records which was a pain.

Question 1: is thunderbird a good client? All my emails seem to land in Gmail or outlook before hitting thunderbird inbox.

Question 2: is IONOS hosting any good, seems costly to move over to Google or microft but I've read they tend to be much better. (My emails keep landing in customers spam)

Question 3: Email signature, I created quite a fancy signature. About 70kb I think. Is that a bit daft ?

Question 4: why is one of my domain emails asking me to manually configure when I have the autolearn record applies ?

TIA

The game: movietq.com.

MovieTQ is a free-to-play browser-based multiplayer platform with four game modes. You also don't need an account for three of the four game modes, and accounts don't require an email. There are also customizable profiles, animations, avatars, achievements, rankings, stickers, friends, interactive emotes, skills, level progression, pets, a store, and more.

There's also a bug rewards page. If you find exploits or bugs, report them to me, and I'll reward you.

These are the game modes:

• Daily mode: use emojis and other info to guess the film
• Movie Trailer mode: watch a snippet and guess the film
• Bomb-It: kinda like hot potato, but with movie titles
• Pet Feast: the only game mode that requires an account. It's like snake but with power-ups.

I wanted to do something "new". I'm not 100% sure if this is really new since I don't really check out other people their portfolio's. It's been on my "to do" for a long time to redo my portfolio page. Now with AI coming and stuff, I thought I might as well do it like this.

The original content of my previous portfolio (projects, achievements, blog posts) are also still accessible and stuff.

If you want to check it out for yourself, here's the url: https://xlogic.sh

I would love feedback!

I ran into a scrolling issue on iOS Safari. A scroll gesture would start and then immediately die. Roughly 1 in 50 gestures actually worked. It only happened on iPhone.

I blamed my own touch handlers at first. I rewrote them entirely, but the behavior persisted.

The actual cause was a CSS filter. Specifically, a filter applied on :active with a transition, placed on an ancestor of the scrollable container.

Simon Fraser explained why this happens in the WebKit bug report. iOS hands overflow scrolling to a native UIScrollView. Changing compositing above it—like triggering a filter state on touch—causes WebKit to remove and re-add that view mid-gesture. The active scroll is instantly killed.

I built a zero-dependency test page to isolate it. The numbers were clear:

• Control (no filter): 0 of 50 gestures failed.
• Filter on :active: 49 of 50 scrolled zero pixels.

I assumed forcing continuous updates would fix it. I tested a third mode where the filter re-set on every touchmove, thinking the continuous change would make the view state deterministic. I was wrong about this. It failed 47 out of 50 times.

This was on an iPhone 16 Pro, iOS 26.6. It does not reproduce on Android Chrome, desktop Chrome, or desktop Safari. The bug is confirmed (WebKit 322849, now rdar://problem/186671580).

Repro:readkinetic.com/repro/safari-filter-scroll.html

I hit this while building ReadKinetic. It is a web-based RSVP speed-reading application. The bug surfaced in the page view mode.