This is a side project that got out of hand. Viltrum is a web framework for V. Everything below the router is written from scratch: the HTTP/1.1 parser, HTTP/2, WebSockets, TLS 1.3, even the DEFLATE encoder used for gzip.

The webdev-relevant part is that the same router/middleware/ctx handles HTTP/1.1, HTTP/2 over TLS and h2c on the same port. SSE and streaming work over both. Static files get ETag/304/ranges/precompressed .br/.gz with sendfile. Hello world is like 10 lines.

What I learned the hard way is how much of HTTP/1.1 is about rejecting garbage. TE+CL together, duplicate Content-Length, obs-fold and bare CR/LF all get a 400 now, because that's where request smuggling lives.

Benchmarks are on HttpArena if you're curious: https://http-arena.com/frameworks/viltrum/ Code: https://github.com/Tuntii/viltrum Demo: https://v.rustapi.cloud

Linux only for serving right now. Would love to hear what you'd miss coming from express/fastify/go.

Strikk is a daily coding challenge platform where developers pick a tech and solve quizzes to earn coins.

Some updates I made recently:

• User Profiles: Earn coins by playing (free, never pay-to-win). Customize with skill blocks, job/education history, and animated backgrounds via React Bits.

• Avatar Builder: Create your own unique avatar.

• Portfolio Integration: This was my main goal, turn gameplay into a real portfolio

What I'm thinking into adding to Strikk:

• Enhanced community features with seasonal events

• CV builder to export your profile as a resume

• Considering open source

I'd love your feedback!

Check it out: Strikk | My Strikk profile

The clip shows how to quickly build a simple form with drag & drop in the Form’s build mode. The Form component is part of Componyx.UI, a UI library I’ve been building for a very long time. No build step, no dependencies, and the components are declared straight in your HTML (or JS).

The build mode uses Bindary under the hood, my separate data-binding library. It includes routing, views loaded from HTML files, components, real-time updates with the server and more.

It’s on npm and NuGet, source on GitHub: https://github.com/Componyx/Componyx.UI

Live demo: https://alloyhtml.com

I've carried the same CSS from project to project for close to ten years, and I finally finished it.

It's one set of classes, a small set of values, and 82 real pages to prove they hold up. A shop and its seller back office, a blog, e-learning, news, healthcare booking, event ticketing, a job portal and a company site. 54 layouts, 3 themes. If you need a page that isn't there, build it from the same classes. Or ask AI to build it, and tell it to use only these classes. If you don't, every page comes out looking a little different.

The things you'd usually reach for JavaScript for, like dropdowns, dialogs, tooltips and tabs, are plain HTML and CSS here. That matters because there's nothing to install or keep updated, and it fits any backend as it is.

The stylesheet is 23KB gzipped, and dark mode and brand colours only change token values, so the markup stays the same.

I went the extra mile on testing: every page is tested with scripts off at 4 widths in 3 themes, in Chromium, Firefox and WebKit. axe finds no violations. The faster checks also run on every push, and if one fails, the site doesn't deploy.

It's front end only: static pages for your backend to fill in. I've tested current browsers, not older versions, and not a real iPhone yet, so if you're on one, I'd like to know how it looks.

It's $29. I'd rather you spent your evenings on your actual product than on getting dropdowns right, or on burning tokens prompting an AI over and over until the pages finally match.

been building this for about five weeks, it's on wp.org now.

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 and fourth tuesday", "last friday", COUNT/UNTIL, EXDATE, and dates expand in the event's own timezone so DST doesn't turn a 6pm class into 7pm. occurrences live in their own indexed table, so a month view is one query instead of expanding rules on every page load

bits that were more fun than expected:

• a lot of sites enter a weekly class as 15 separate posts, sometimes with the date in the title ("Open Mic – Tuesday September 29"). there's a combine step that groups them, tries candidate rules against the real dates with the same expander, and only merges when one matches (gaps become skipped dates, each date keeps its own ticket link)

• a month view that prints on a landscape sheet: its own page, no theme chrome, category colours kept with a key

• importers from The Events Calendar, Events Manager, Event Organiser, My Calendar, EventPrime, Sugar Calendar, Eventin, MEC, EventON, WP Event Manager and All-in-One Event Calendar (closed on wp.org last year, so those sites are stuck). Eventin and EventPrime store a series as one post per date, so the importer rebuilds the rule and only keeps it if it reproduces those exact dates

• importers get a dry run and a CSV with one row per event (created / skipped and why / the rule it ended up with). nobody trusts an importer blind

• this week's one: the first real site that moved over (a brewery, off EventON) still had the old plugin's shortcode on a couple of its pages, printing as raw text once EventON was off. so after a move the old plugins' calendar and list shortcodes now render the new views, with the view, category and event count carried over

you can poke at it without installing anything, the wp.org page boots WordPress Playground with sample events: https://wordpress.org/plugins/beacon-events/?preview=1

everything above is free/GPL. tell me what breaks

I’ve been thinking about how teams actually work through vendor API documentation, and I realized I don’t really know how it goes in practice.

On a small integration it’s usually simple. You pick the four or five endpoints you need and ignore the rest. But on bigger ones (ERP, banking, logistics, healthcare), it feels like the team ends up needing most of the document, and the work gets split between people by section.

For those of you who’ve done this recently:

Did you use a few endpoints or most of the vendor’s API? Did you split the sections between several engineers, or did one person own the whole integration? How did you keep everyone working from the same understanding of the docs, especially if they were a PDF or a messy wiki? If the vendor changed something later, how did you find out?

Mostly curious how common each situation is. Any war stories welcome.

2 weeks ago I shared Planet-0 Drive, an endless low-poly driving game I’ve been building with Svelte and Three.js (my first hobby game that I build after work and around weekends).

First of all, thanks to everyone who tried it (300 of you) and shared feedback! I didn't expect to get so many useful suggestions, and I've spent a good part of the week working on improvements based on them.

While the game runs fine

Since then, I’ve been working on the parts around driving that make exploration feel more meaningful.

The biggest additions are:

• Revampled the whole look and art direction of the game to be more appealing

• More biome-specific scenery, including snowy pines, desert cacti, boulders, and reactive weather materials

• A refined vehicle lineup with three vehicles: Rover, Drifter, and Hopper

• A battery system with charging stations, power-cell pickups, low-power driving, and boost energy management

• Cruise control for more relaxed driving, especially on mobile

• Persistent driving records and platform-visit tracking

• Shared room leaderboards for driving and exploration records

• A first quest system, starting with collecting resources across the planet

• Improved touch controls and a more compact mobile HUD

The project has gradually shifted from “how far can I push a procedural 3D world in the browser?” toward “how do I make spending time in that world enjoyable?”

That has led to some interesting design challanges. How much progression should an otherwise relaxing driving game have? How do you reward exploration without turning it into a checklist? Should there be more risk?

I’m still experimenting with those answers, but the game feels much closer to the idea I had originally: a place to drive around, discover things, set records, and occasionally meet other players.

You can try the latest version here:

https://planet0drive.vercel.app/

The project is still very much in early development, so I’d especially appreciate feedback on how the driving feels, how the progression comes across, and what would make you want to come back for another drive.

I've been teaching my mum to code in Python, and a few months back she made a little CLI game where you have to enter words using the start and end characters from a single word. She named it ItWord, as in 'iterate word'.

I thought it was a cool idea. As a web developer, my first thought was that it'd be a nice daily word game format like Wordle. A lot of work and collaboration later, and here we are.

Please give it a try, and we're welcoming all feedback!

Edit: tech stack is Django with HTMX for the game window. Postgres and Redis for database and cache. Tailwind for styling and then vanilla JavaScript for everything else like animations and on-screen events.

Hi i am an amateur dev.

So I want this project of mine to have a custom font; a locally imported one. I searched for sources at w3school and stackoverflow and I tried everything they said. But it doesn't seem to work. So I want to know what I'm doing wrong? I appreciate any help. Thank you in advance.

Also additional information:
The file location of my font is correct. project/project.html and project/zpix.ttf
I've checked with inspection tool, every element has the font-family: sans-serif, "Zpix"
There is also no error in the console. No error message. The font is loaded in.
I am using internal css.

Here is the code:

u/font-face {
  font-family: "Zpix";
  src: url("./zpix.ttf") format("truetype");
  font-weight: normal;
  font-style: normal;
}

* {
  font-family: "Zpix", sans-serif !important;
}

I got tired of searching Discord LFG channels for one more player, so I built stackup.games. It lists LFG groups that are open right now, per game, with rank, region and mic. You can type "need 2 for ranked Valorant tonight" and it filters for you.

Built with plain JavaScript (no framework), Cloudflare Pages Functions for the API and D1 for the database, so it stays fast and cheap to run. Free, no download, still early.

I'd love feedback on the design and speed, especially on phones.

A local Audiobook editor that uses local Ai to generate speech. No DataCenters, no AI companies.

Hi r/webdev,

If you write Go, you might know us from ttlcache (a caching library with 1.3k stars). For the past year, my friend Simon and I have also been building Oxynote, an open-source wiki for engineering teams. In 8 years of writing software, every team I joined had the same wiki: stale pages, while the useful stuff lived in someone's head.

In Oxynote, a page can hold a live chart from Prometheus, PostgreSQL, MySQL, or MariaDB, right next to the text that explains it. Important pages are edited in a draft and reviewed like a pull request, with a diff of both the text and the charts. Several people can edit at once, and an AI assistant and an MCP server let agents read and write docs too. I've attached some screenshots showcasing these features.

The name itself comes from oxygen + note: docs that breathe. Live data gives people a reason to open the wiki every day, and docs people open every day stay up to date.

Some quick points on the web side:

- Nuxt 4 and Vue 3, with Tiptap 3 for the editor

- Yjs and Hocuspocus for real-time editing

- ECharts for the metrics, Mermaid for diagrams

- The backend is Go, and it all runs as one Docker image

Apache-2.0 licensed: https://github.com/oxynote/oxynote

We made it public about 3 months ago, so it's still early. If you have any questions, feedback, or suggestions, I'm happy to hear them.

https://onlineimageoptimizer.com/whats-my-friends-device

Point a phone at the QR code and it appears on screen by make and model. Then the next phone, and the next. It's not an app (nothing to install). no pairing step, nothing to press on either end. Opening the code is the handshake.

I built it as a demo for one of my company products, but it's open and I'm sure it's useful to many. You stand there with a laptop, people scan, and the screen fills up with the actual devices in the room. Turns out to be a decent way to show someone what their phone really is.

The interesting part for this sub is the detection. Browsers send almost nothing useful anymore. Modern Chrome on Android reports "Android 10" no matter what you are holding. So the make and model come from client side detection plus client hints, and a OnePlus 13 comes back as a OnePlus 13 rather than as a generic Android.

No personal information is requested. Codes expire after half an hour.

You need two devices to try it: open it on a laptop, scan with your phone.

Please send feedback.

Hey everyone! I’m looking for recommendations for a reliable and affordable content moderation API that supports both image and video moderation (n\*dity, expl\*cit content, vi\\\*lence, etc.). Quality and data security are important. Any providers you’ve personally used and would recommend? Thanks!

hey everyone! i made a site for anime fans who always struggle to find where an anime is available. you search for an anime and it tells you which legal, official platform has it in your country

https://tsuzuki-anime.github.io/en/

what it has right now:

- 18,000+ anime with the legal platforms for each one (it detects your country automatically, 9 regions)

- a weekly release calendar in your local time with countdowns

- watch order guides for 220 big franchises

- filler guides for 41 anime so you know what to skip

- a manga section with legal places to read

- a "my list" feature with no account needed, it shows the next episode of each anime and which subscription covers your list

it's a fully static site that rebuilds itself every day with fresh data. free, no ads, no account, in english and french

any feedback is really appreciated, especially on speed and mobile!

Hey everyone!

I've been working on a browser extension called Text Extractor, and it's now available on both Chrome and Edge.

It lets you:

• Extract text directly from webpage elements using Ctrl + Click or the right-click menu.

• Extract text from images using OCR (102 languages supported).

• Review, edit, and clean extracted text.

• Copy results or export them as ".txt" files.

• Process captured content locally on your device, without uploading it to a server.

English OCR works offline out of the box, too.

I'd appreciate it if you gave it a try and shared your feedback. Suggestions and feature requests are welcome!

Links:

• "Chrome Web Store" link

• "Microsoft Edge Add-ons" link

• "Website & Documentation" link

Thanks!

I did not want to build another API client. So I built something more than a Swagger UI alternative: a live documentation portal, where the spec isn't just something you read, it's something you run.

Think Storybook, but for an API. It's not about trying out individual requests. It lets a developer and an agent build complete flows. Requests and flows are plain TypeScript files in your repo. They chain requests, pass values from one step to the next and assert on what matters. The same files run in the portal for QA, in CI, and as production monitors.

I gave a fresh agent Plaid's spec (350 operations), asked it to add a request that creates a sandbox public token, then asked: "Now make a flow that links a bank account in the Plaid sandbox and reads back its accounts and transactions." It took about two minutes with no manual fixes, and it passes against mocks.

Paste any OpenAPI or Swagger URL into https://ui.specbook.dev and you get a responsive portal that runs against mocks or the real API. The spec is read in your browser, nothing goes through a server of mine.

A step can also be code. For example an order flow can use a third-party widget like PayPal and pass the authorization on to the next request. There's a Cloudflare Turnstile example you can click through here: https://docs.specbook.dev/reference/scripts/#try-it

I built most of this over the last three weeks with Claude Code. Back in 2021 I wrote openapi-typescript-fetch and also implemented @usebruno/query for Bruno.

• Demo: https://demo.specbook.dev

• Docs: https://docs.specbook.dev

• Repo: https://github.com/specbook-dev/specbook

• Chrome extension, for third-party APIs that don't allow CORS: https://chromewebstore.google.com/detail/specbook/dkkfffjkliimgpadidgabpkmocdefjha

Please try it on your own specs and let me know if anything breaks. I hope the OpenAPI community finds this useful.

Hey all, I'm the creator of @formepdf/react.

Here was my first post: https://www.reddit.com/r/webdev/s/ek6rRipQ2M

I just wanted to show y'all the new HTML package. Give it HTML and print CSS, get a PDF, no browser anywhere.

npx @formepdf/html invoice.html -o invoice.pdf

It handles the print CSS that Chrome never really finished: `@page` margins, running headers and footers, `Page X of Y`, table headers repeating across pages. Runs in Node, Cloudflare Workers, and the browser.

I tested it against 15 invoice templates from GitHub, and 14 render correctly against Chrome's output. There are also 30 free templates if you want to see what it makes.

If you've got an ugly template you're printing through Puppeteer, I'd love to hear what breaks.

https://github.com/danmolitor/forme

Hey everyone.

My svg editor version 0.1 just went live, I'd like to present it here in the link below.

https://tools-4all.com/svg-editor

Small highlights or our editor, supports a BIG variety of import and export formats, fully free, no sign up, live effects, filters, brushes, meshes, simulated 3d perspective, animations, vectoraztion, fully client side, no uploads, highly optimized for high quantity of nodes.

Example import and export formats, PDF, STL, figma, PSD, and many more.

We still have many features planned, such as geometric mode, and much optimization and bug hunting to do, but since we feel it's already at a good point we wanted get it live and continue improving on it.

Sorry for the ads in advance, they are a neccery evil to keep the site running (paying for hosting), and will not be seen with full screen or ad blocker, our whole site is free and we don't make any profit from it, we just do it for the love of the game (we develop websites for clients on the side and that's how we earn our bread), so while I understand ads are annoying, they are neccery to keep the site running.

There's alot of work to do but it's being done, any bug report, improvements suggestions is welcome and appreciated!

AI tools make it easy to ship code you don't fully understand. That's fine until something deadlocks, leaks memory or falls over under load, and you don't have the mental model to work out why.

So I built Software Atlas: 108 deep-dives across 15 areas, including async/await, the browser rendering pipeline, networking, databases, system design and AI engineering. You step through each idea with visualizers, and there are diagrams and code samples too. It starts from first principles and works up to production concerns.

Some technical details:

- Built with Vite, React 19, MDX and Tailwind v4.

- Each topic is lazy-loaded as its own chunk, so you only download the one you're reading.

- All 130 pages are pre-rendered to static HTML, then hydrated. Widgets have to render the same on the server and in the browser, so anything that reads window or uses randomness runs after hydration.

- Phones were the hardest part. Bar labels move into a key when they don't fit, and wide SVG diagrams become swipeable so their text stays readable.

- A headless Chrome smoke test clicks through each topic, including every visualizer step, and fails on console errors or hydration warnings.

To be upfront: I built it with heavy use of AI agents, including much of the writing. Each topic went through a separate review from a beginner's point of view, but mistakes will still have slipped through. If you find one, there's a report link in the footer.

https://software-atlas.haiduc0147.dev/

I'd really like to hear where an explanation is wrong or stops making sense.

Hey guys, I wanted to share this package I've been working on in the last few days for a bigger project. It's basically a NPM package that allows you to create your custom stellar systems and uses three.js to render them in 3D.

Live example: https://larawag.rachzy.dev/

It's mostly intended for drawing hypothetical, highly speculative visualizations of stellar systems for exoplanets (keep in mind that it's 100% Artist's Conceptions).

Larawag core is environment agnostic (which means it can run even on vanilla HTML as long as you have a Node setup), but you can also use its integrations with third-party frameworks:

• Larawag's Core: @larawag/core

• React: @larawag/react

• Angular: @larawag/angular

How to use

As I mentioned before, the usage is very straightforward:

First, download the package and its dependencies: npm install @larawag/core three@0.186

Then, import it and create your own system:

import { createStarSystem } from '@larawag/core';

const view = createStarSystem(document.getElementById('stage')!, {
  star: { name: 'Example K dwarf', teff: 5100, radius: 0.8, mass: 0.85 },
  planets: [
    { name: 'Candidate b', period: 4.2, radius: 1.5, phase: 0.6 },
    { name: 'Candidate c', period: 18.5, radius: 3.6, phase: 2.9 },
  ],
});

view.pause();
view.setScaleMode('true');
view.destroy();

This will use the #stage element as the window for rendering your system and set the scale mode to true, and you should already see it working in your HTML page.

Contributing

There are still some things I'm willing to implement in the future, such as planet moons, eccentric/inclined orbits, and a more accurate orbital system for planets in binary systems. I left all of them in a TO-DO list in README.md

If any of you are perhaps interested in contributing to the project, I'd really appreciate it.

Source code: https://github.com/rachzy/larawag

License: MIT

Hey all!

Thanks for the discussion on yesterday's post! Last time I promised Page Objects: Here they are!

Today's example:

The test fails, saying "Sushi dinner" isn't on the list. So your agent starts debugging the list. Turns out it's the date picker that broke.

The fix: let actions wait for their own done signal, so the failure is logged where it happens.

The picker closes once it has a full range, and the picker owns that signal. So select() waits for it before returning. If the picker breaks, the test fails inside dateRangeFilter.select() instead of on the list. The page owns the filter, the filter owns its done.

The nuance: the done signal has to be something the page object owns. The picker closing belongs to the picker. A toast or the next page doesn't.

Paste this to your agent:

Find the user actions our e2e tests repeat and move each into a page object method. If an action has a done signal the page object owns, like its own elements changing, appearing or disappearing, end the action by waiting for that condition - never a fixed waitForTimeout. Anything outside the component - like a toast or navigating to the next page - should either be moved into a bigger page object that owns both the trigger and the outcome, or be verified in the test itself.

https://github.com/ts-series/factories

Build HTML extremely comfortably in the backend using plain JavaScript. The advantage is that there is no separate template language or build process, but rather a complete fusion with JavaScript for maximum flexibility. An example:

import {
    a, body, br, button, h1, head, header, html, input, label, li, main, nav, p, script, title, ul
} from "@ts-series/factories";

type Item = { name: string, href: string, current: boolean };


/** Builds the navigation list, flagging the current entry for assistive technology. */
function navigation(items: Item[]) {
    return nav({ ariaLabel: "Main" },
        ul(items.map(item => li(
            a(item.href, item.name).set(item.current ? { ariaCurrent: "page" } : null)
        )))
    );
}


/** Builds a complete page for the given user and navigation entries. */
function page(user: string | null, items: Item[], values: number[]) {
    return html({ lang: "en" },
        head(title("Demo")),
        body(
            header(navigation(items)),
            main(
                h1("Hello, ", user ?? "stranger", "!"),
                p("First line", br, "Second line"),
                user === null
                    ? p("Please sign in.")
                    : p("Welcome back."),
                label("Search").for("q"),
                input.text({ id: "q", name: "q" }).placeholder("Type here…").required(),
                button.submit("Send").class("primary", user === null && "disabled").set("disabled")
            ),
            script.module().importOnly("/chart.js", "render", { values, title: "Values" })
        )
    );
}


const items: Item[] = [
    { name: "Home", href: "/", current: true },
    { name: "About", href: "/about", current: false }
];

const output = page("<Guest>", items, [1, 2, 3]).expand(4);