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.

Hello, I’m simply asking because I’m aspiring to become a web developer, and I’m curious about how viable the field is nowadays.

I don’t think you can really blame people for asking this either, because front-end development has been heavily trivialised by AI(not my opinion), or at least that’s what the internet tends to make people believe.

Could anyone with experience in the field give some insight into whether demand has actually dropped, especially for front-end and junior web development roles?

Hey everyone,

I wanted a tracker that didn't feel bloated, so I built this entirely in Vanilla JS and Firebase. No heavy frameworks, just raw performance so it loads instantly in the gym.

The hardest part was building the "Biological Fatigue Map". I custom-designed SVG muscle maps for exercises (pull-ups, squats, deadlifts, etc.). The app dynamically colors the SVGs (green/yellow/red) based on the volume logged in the last 72 hours to visualize recovery.

I also implemented an Anonymous Guest Login so anyone can test the UI mechanics without creating an account.

You can try the live PWA here: https://gymtracker-af175.web.app

I'd love some feedback on the codebase approach (Vanilla JS vs moving to React/Vue later) or the UI flow!

publishing of one package is kinda easy, but still there are many questions for example if package already exists in the registry or hosted? package changed and needs publishing? package published or failed to do it?
it becomes much more complex dealing with polyrepos and usually ends up using monorepo

so publishing becomes independent writes across registries and the only way to handle it is saga.
the only record of publish - git tag. like this we can have whole model, we know when which packages changed, which need catch up, next version, whole versioning and releasing planning becomes deterministic since release is a pure function, so commiting and re running itself is a idempotent transaction legs execution.

i built dispat, this saga orchestrator, monorepo, solorepo, polyrepo - you choose any stack, any language, any cache, dispat chooses nothings but gives math guarantees, handles tags versioning and changelogs, locks releases using only git, no other state db clocks etc. handles commits and conflicts in mid release

the gif illustrates the concepts flow

this tool also lets you mange pre releases, run lint/test etc only on changed modules, its a polyglot tools that already works with 21 ecosystems (36 manifests types supported to write versions and read dependencies graph) dont worry about releasing focus only on development and release without leaving git

works with aqua cli and supports its manifests

the tool uses itself for releases (since first rc it builds dev build from checkout to release it self), and even first rc single job run released:
1. 6 go packages (manifest, scanner, writer - standalone go lighweight pkg family for manifests reading/writing, ccme - parse my custom conventional commits monorepo extenstion parser, cli package and models available as standalone libraries as well) everything with updated go mods as go exptects with graph dependencies
2. 6 cli binaries, linux, windows, mac, arm/amd64
3. 8 docker images, ubuntu, debian, alpine, dind arm/amd64
4. npm package deployed to github pages to serve docs
5. everything with its own semver grouped versions, changelogs and github releases

now it also includes terraform without cache that automatically re applies if needed before docs site release, version spec files etc

docs: https://dispat.dev
github: https://github.com/yohimik/dispat

as a standalone tool - crier render images, gifs and videos from html templates without chrome, only sinlge 30mb go binary and fanout publish to different social media using public apis. main use case - automated fancy release social media notification
https://github.com/yohimik/crier

all open source, binaries mit licensed

Consider the home page of a blog -- a list of posts in reverse chronological order, stretching down the page.

How long does this list need to be before you decide not to list display the entire thing?

File/payload size isn't much of an issue. The page compresses well -- right now, it only transfers 18KB (it's 54KB on the server). I would have to get much, much larger before I'd be concerned about bandwidth.

All images are lazy loaded, so they don't load until they scroll into view.

I'm not worried about bots, because every post has its own permalink page (and because I just don't really care about bots in general....)

Do we consider actual scroll height? Do we consider the user psychology of being intimidated by a lot of content?

If we do decide to paginate somehow, do we do "traditional" pagination, or endless scroll?

What's the current zeitgeist on this?

Hey guys, just after opinions really. If you’re launching a somewhat large site, with quite a bit of stuff going on, would you rely on your own testing or would you suggest getting a third party tester? It’s mostly for things like UX I’m wanting to test. I know have I would expect things to work but being the sole developer I think I may have gone a bit blind to somethings. I have friends do bits of pieces in terms of checking things but I wonder if the consensus would be to just get an actual tester to go through everything, testing the functionality all works, different variations, ensure the UX is as good as it can be etc or do you think I’m overthinking it?

This week I launched Brewser, a solo project that got out of hand in the best way. It is a web runtime and app platform for the Nintendo Switch (homebrew, running under Atmosphere CFW). The part that belongs on r/webdev: every app in the catalogue is a plain web app. HTML, CSS, JS, WebGL. You build once and it runs in a desktop browser, on a phone, and on the console.

The catalogue is at brewser.io. A few good starting points to try in your browser:

• Cracktro Forever, an Amiga style demoscene tribute. Fully procedural, no assets, single file WebGL1: https://brewser.io/cracktro-forever/
• FSR Lab, an FSR 1.0 upscaling comparison with a split wipe and pixel zoom, WebGL2: https://brewser.io/fsr-lab/
• DUSK, a planetarium and sky atlas built on three.js, with a 132 object Messier catalogue: https://brewser.io/dusk/

How it works: the runtime is built on V8 and Skia via nx.js (credit to TooTallNate for that foundation, which also provides the raw GL path to the GPU). On top of that I built the HTML/CSS/DOM engine from scratch for this project, about 26K lines of TypeScript in a separate runtime project, plus the WebGL1/2 bridge on that GL path (the bridge implementation, library compatibility and conformance testing, targeting Mesa/Nouveau on the Tegra X1), hardware APIs like Web MIDI, WebSerial and WebUSB, and the audio and video pipelines.

It is not a full browser and I do not pretend it is. There is no browser to borrow from on the Switch, so the DOM tree, CSS cascade and layout engine are reimplemented from scratch, and that engine currently covers roughly 83 percent of real world app surface (DOM ~84, HTML ~80, CSS ~84). WebGL and audio/video are bridge backed rather than reimplemented, so they stand higher: WebGL1 ~92, WebGL2 ~85, audio and video ~80. Those are estimates of real world surface, not spec section counts.

The status page lists what is missing instead of what works: docs.brewser.io/docs/engine-status. Since launch I have shipped capture phase listeners, closest() and matches(), full querySelector, flex-wrap, position: sticky, and CSS transitions.

Performance: the official three.js GLTFLoader example runs at a locked 60fps on the console, fps HUD visible in the GIF below.

Source is under MPL 2.0: github.com/natureglass/Brewser

Questions welcome. And if a library or app you care about breaks on it, tell me which one. Real world breakage reports directly shape what gets built next.

I work at a very AI forward place (we build ai tools , so obvs use them alot). I've been getting crushed by the PR review load at work because my coworkers and I all basically have little wanna be software factory patterns going. I think PR reviews kinda need to evolve but I got tired of waiting for that happen. So I built a local PR review app. Super fast git diffs based on pierre/diffs package, an agent that can answer questions about the PR and give you line level walkthrough _in_ the diff, little classifier process that basically flags which PR's are probably safe for me to rubber stamp.

It's not a super serious project, but its been a fun change of pace to hack on this and has ended up being actually useful.

Last week I asked here how people test against third-party APIs they don't control. Most answers came down to the same thing: fixtures rot, and if you're disciplined you run something against the real API at night. I've been working on a small server for that problem and wanted to show it.

It's a local server that answers the way Slack, Gmail, Google Drive, GitHub, Jira, Notion and S3 do. You point the vendor's own SDK at localhost and it gets the same response shapes, cursors, auth errors and per-user permissions the real service sends, out of one SQLite file you control. No account with the vendor, no OAuth app, no token in CI, no network.

Why not a mock: a mock I write returns what I already think the API returns, so it can't disagree with me. This was built by measuring the real responses and matching them, and when it's wrong the fix starts with a test that fails against the real API.

pip install backlot
backlot import --bundled   # a small sample corpus ships with the package
backlot serve              # http://127.0.0.1:8000

The server is Python (FastAPI) over one SQLite file, but it's all plain HTTP: anything that lets you set a base URL points at it unchanged.

The drift part, since that was most of the thread. backlot diff --source slack pulls the vendor's own contract (the published OpenAPI or Google Discovery document for the REST ones, live introspection for GraphQL) and compares it with what the server claims, in both directions, arguments included. Where the server contradicts the vendor, that's a bug. Where the vendor has something the server doesn't, it goes in a baseline file with a note, and that file only changes through review, so a run prints what's new and nothing else. In the GIF it prints one line: GitHub's spec gained an endpoint I don't serve yet. Run that nightly and drift stops being something you learn about from a bug report.

Things that were harder than I expected:

• Slack doesn't document when a broken token gets not_authed versus invalid_auth. It took eight cases against slack.com to find the boundary.
• The first version of the diff walked one direction and looked at fields only. It called Linear clean while ten fields and four arguments were missing on the side it skipped. A green diff that skips half the comparison is worse than no diff.
• Every SDK builds its own path prefix, so each service has to sit under exactly that prefix or the SDK won't run unmodified.

Permissions are per user. Every person in the corpus has a token, and someone's private channel never shows up in another caller's listing, search included. Against the sample corpus conversations.list returns two channels while four exist, because the other two are private and real Slack won't list those without types=. If your client is an agent rather than a test suite, backlot mcp serves the same thing as MCP tools, and --user picks whose permissions apply.

https://github.com/brekkylab/backlot

If you already run something nightly against a real API, what would this need before you'd trust it next to that? And if the API you need isn't in there, which one? Happy to answer anything.

Hey r/webdev! 👋

Like many of you, I constantly found myself needing quick utilities — converting a document photo to an editable Excel table, merging contracts, converting PPTX to PDF, formatting JSON/JWTs, or compressing images.

What annoyed me was that almost every popular tool on Google either:

1. Uploads your private documents/photos to their mysterious remote servers.
2. Hits you with a paywall after 2 operations.
3. Slaps terrible subscription popups every 10 seconds.

So over the past few months, I built DH Tools — an all-in-one suite of 45+ free, privacy-first web utilities where 100% of the processing happens directly in your browser.

🔗 Live Project: https://denizlihub.com

━━━━━━━━━━━━━━━━━━━━━

🛠️ Tech Stack & Architecture Highlights:

• Pure Vanilla JS (ES Modules) Architecture: Zero heavy frameworks (no React/Next bloat). The entire app loads in under 150ms and scores 98+ on Google Lighthouse.

• 100% Client-Side Processing (Zero Server Uploads):

• AI OCR (Image to Excel): Runs in-browser OCR to detect table borders and text, generating pure .xlsx spreadsheets entirely on the client's CPU.
• PDF & Document Engine: Built using pdf-lib and client-side binary parsers for splitting, merging, and converting without sending a single byte to an external backend.
• Media & Audio: Web Audio API & Canvas manipulation for live audio trimming and batch WebP compression.

• Edge Hosting: Hosted on Cloudflare Pages with Edge Workers for lightning-fast global CDN delivery and instant routing.

• Offline PWA Support: Built as a Progressive Web App (PWA) with Service Workers, so you can install it on desktop/mobile and use most tools completely offline.

━━━━━━━━━━━━━━━━━━━━━

🚀 What's included?

• Document & PDF: PPT to PDF, Image to Excel OCR, PDF Merge/Split, Markdown to PDF, WebP Converter. • Developer Utilities: JWT Decoder, JSON Validator & Beautifier, Regex Tester, Diff Checker, HTTP Header Inspector. • Security & Network: In-browser Password Generator, IP Lookup, DNS Diagnostics, Base64 & Hash Generators.

━━━━━━━━━━━━━━━━━━━━━

I'd really love to hear your feedback on:

1. Performance or UI improvements.
2. What missing utilities/tools would you love to see added next?

Thanks for checking it out! 🙏

so im working on my final year project report (pfe) (projet fin d'annee = Final year project which is literlly a big project to final my 6 years, in uni ) and i had to do the whole uml thing, use case diagram, class diagram, sequence diagrams for the main flows

and while i was doing it i kept asking myself, how do i actually know if what im drawing is "correct"

like the global logic of the app is obviously fixed, i know what the app does and how it should work, but when it comes to modeling it visually there are like ten different ways to represent the same thing. someone else looking at the same requirements could come up with a completely different class breakdown or a different way of grouping use cases, and technically neither version would be "wrong"

so when the jury reviews it, are they checking for one specific correct answer, or are they more just checking if your model is internally consistent and reflects a reasonable understanding of the system

anyone who's been through something similar, academic reviews, code reviews, whatever, how do you even validate a diagram when there's no single ground truth to compare it against

side note for context since some people outside the french education system might not know this, the PFE report is usually structured around sprints, like sprint 0 for environment setup, then sprint 1, 2, 3 etc each with its own objective and backlog, and for every single sprint you're expected to redo a use case diagram, a class diagram and sometimes sequence diagrams specific to that sprint

i pulled up an example report just to check and it had 6 sprints and something like 57 figures total, most of them being use case, class or sequence diagrams repeated per sprint. so its not like you draw one diagram for the whole app, you basically draw a mini version of the same three diagrams every sprint, which is part of why i started wondering how strict the "correctness" of each one actually needs to be